blog.atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom"><title>The L Blog</title><link href="http://lmontopo.github.io/" rel="alternate"></link><link href="http://lmontopo.github.io/feeds/blog.atom.xml" rel="self"></link><id>http://lmontopo.github.io/</id><updated>2016-11-06T05:00:00-05:00</updated><entry><title>What's frontend, what's backend?</title><link href="http://lmontopo.github.io/frontend-backend.html" rel="alternate"></link><updated>2016-11-06T05:00:00-05:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2016-11-06:frontend-backend.html</id><summary type="html">&lt;p&gt;Last week a co-worker of mine asked me to clarify for him what the difference was between backend and frontend web development.  I had been asked this quesiton before, but this was the first time I felt I provided a clear explanation and was able to instill knowledge.&lt;/p&gt;
&lt;p&gt;So, here, I'd like jot down a lof of the key points which I think helped to clarify the meaning of and the difference between 'frontend' and 'backend' development:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Backend code is run on the server computer while frontend code is run on the client computer.&lt;/strong&gt;  &lt;/li&gt;
&lt;li&gt;Being a &lt;em&gt;fullstack developer&lt;/em&gt; means that you write (or can write) both backend and frontend code. &lt;/li&gt;
&lt;li&gt;The backend takes care of any logic that the server needs to run before a response can be sent to the client.  This includes things like retreiving data from a database, authenticating a user or making some calculations.&lt;/li&gt;
&lt;li&gt;The frontend code takes care of any logic that needs to run locally - on the clients computer - in response to user interactions.  This includes any subsequent network calls for updated data.&lt;/li&gt;
&lt;li&gt;Frontend code is usually written in JavaScript, which your browser can interpret.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;Why can't I write frontend in Python (or can I)?&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Just like all browsers know how to turn HTML and CSS into pretty pages, all browsers know how to 
interpret JavaScript;  &lt;strong&gt;All browsers have built in JavaScript interpreters.&lt;/strong&gt; &lt;ul&gt;
&lt;li&gt;Check it out!  In Chrome right click on a page and click on the 'inspect'.  Then click on the 'console' tab.  You are now looking at a JavaScript Interpreter!  For fun, write the following: &lt;code&gt;alert('Leta is cool')&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Python interpreters aren't currently built into browsers.  It's not that they &lt;em&gt;couldn't be&lt;/em&gt; it's just that they &lt;em&gt;aren't&lt;/em&gt;.  If I wanted to write frontend logic in Python I'd have two choices: &lt;ol&gt;
&lt;li&gt;Write a browser plugin to be able to interpret Python, and prompt users to install it to view my web app. &lt;em&gt;(This type of thing has been done in order to run Java on the frontend! Remember those annoying Java plugin installation promps?)&lt;/em&gt;&lt;/li&gt;
&lt;li&gt;Compile my Python code down to JavaScript before sending it to the client.  This is a bit of a hack, though, because technically javaScript is still what would be running on the client side.&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;Where do HTML and CSS fit in?&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Often HTML and CSS are considered frontend.  The reason being is that, like JavaScript, they are interpreted by your browser.&lt;/li&gt;
&lt;li&gt;I consider HTML to be backend only in the context of a template that will be compiled by a template enginge.  In this case one is writting an HTML page with added template language logic which will render more HTML depending on the data that is fed into it. &lt;/li&gt;
&lt;li&gt;To me, this falls under the backend umbrella because the templatign engine will turn this template into a finished HTML file on the surver side before sending the final HTML file to the client.&lt;/li&gt;
&lt;li&gt;Some people agree with me on this distinction, others disagree (and that's OK!)&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;Further readings&lt;/h4&gt;
&lt;p&gt;If you're curious to know a little more, specifically about why / how JavaScript became the only language built into browsers, I recommend reading &lt;a href="https://www.reddit.com/r/learnprogramming/comments/3frml2/why_is_javascript_the_only_frontend_programming/?st=iv70e8ah&amp;amp;sh=d65bf9be"&gt;this&lt;/a&gt; thread on reddit.  I found it to be well explained and pretty thorough! &lt;/p&gt;</summary><category term="Web"></category></entry><entry><title>How the Internet Works: Domain Names and Routing</title><link href="http://lmontopo.github.io/how-the-internet-works-2.html" rel="alternate"></link><updated>2015-09-14T05:00:00-04:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2015-09-14:how-the-internet-works-2.html</id><summary type="html">&lt;p&gt;This blog post is a continuation of my previous post &lt;a href="http://lmontopo.github.io/how-the-internet-works.html"&gt;How the Internet Works&lt;/a&gt;.  Here, I hope to answer the following questions: &lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Since we don't usually specify the IP address of the computer we wish to connect with, how does our computer successfully connect with it?&lt;/strong&gt; &lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Assuming the IP address of the destination computer is known, How does a request from my computer actually make it to the computer with this IP?  How does it know where that computer is?&lt;/strong&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;The Domain Name System&lt;/h2&gt;
&lt;p&gt;A &lt;strong&gt;domain name&lt;/strong&gt; is a human readable address of a computer on the internet.  Domain names are used all the time for activities requiring the internet, including sending emails and browsing web pages.  The part of a URL&lt;sup id="fnref:1"&gt;&lt;a class="footnote-ref" href="#fn:1" rel="footnote"&gt;1&lt;/a&gt;&lt;/sup&gt; that appears after the protocol but before the file path is the domain name.  For example, &lt;code&gt;lmontopo.github.io&lt;/code&gt; is the domain name in the URL of this blog post: &lt;code&gt;https://lmontopo.github.io/how-the-internet-works-2.html&lt;/code&gt;.  &lt;/p&gt;
&lt;p&gt;The term &lt;strong&gt;Domain Name System (DNS)&lt;/strong&gt; refers to the internet service of translating domain names into IP addresses.  It consists of a distributed&lt;sup id="fnref:2"&gt;&lt;a class="footnote-ref" href="#fn:2" rel="footnote"&gt;2&lt;/a&gt;&lt;/sup&gt; database of IP address and domain name pairs.  Hundreds of servers known as &lt;strong&gt;DNS servers&lt;/strong&gt; are dedicated to working together to translate domain names into IP addresses.  There are two kinds of DNS servers: caching servers and authoritative name servers:  &lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Authoritative Servers&lt;/strong&gt; are responsible for maintaining a database of the IP addresses of domains within its 'authority'. &lt;em&gt;What does this mean?&lt;/em&gt; Well, these servers are organized in a heiarchy that matches the structure of the domain names themselves.  Indeed, domain names consist of one or more domains separated by dots.  The rightmost domain is the &lt;em&gt;top-level domain&lt;/em&gt;.  Examples of top-level domains include &lt;code&gt;com&lt;/code&gt;, &lt;code&gt;org&lt;/code&gt; and &lt;code&gt;edu&lt;/code&gt;. Directly left of the top-level domain is the second-level domain, preceeded by more sub-domains until the leftmost word, the &lt;em&gt;host&lt;/em&gt;.  An authoritative DNS server handles a specific level in this heiarchy and knows the IP addresses of all hosts and subdomains under it. So, for example, an authoritative DNS server with authority over the &lt;code&gt;github.io&lt;/code&gt; domain would know the IP address of host &lt;code&gt;lmontopo.github.io&lt;/code&gt;.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Caching Servers&lt;/strong&gt; are your computer's first point of contact with the DNS. Your computer is automatically&lt;sup id="fnref:3"&gt;&lt;a class="footnote-ref" href="#fn:3" rel="footnote"&gt;3&lt;/a&gt;&lt;/sup&gt; configured with the IP address of a caching DNS server (usually provided by your Internet Service Provider) so that your computer knows who to contact for DNS resolution.  These caching servers communicate back and forth with authoritative name servers on your behalf until they find one that can resolve the supplied domain name into an IP address. &lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;OK, I know this stuff can be confusing, but if you've made it this far, bear with me!&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Let's go through an example to better understand how this works: Suppose we request the IP address of the domain name 'www.wikipedia.org'&lt;/em&gt;:&lt;/p&gt;
&lt;p&gt;As previously explained, our computer will first send a request to the DNS Server (a cache server) specified in its network configuration settings.  Lets call this cache server Jane, since we'll be talking about it lots.  Our computer will ask Jane something like “Can you tell me the IP address of www.wikipedia.org?”. Usually the DNS server provided by our ISP will have a cache&lt;sup id="fnref:4"&gt;&lt;a class="footnote-ref" href="#fn:4" rel="footnote"&gt;4&lt;/a&gt;&lt;/sup&gt; of frequently resolved domain names.  Assuming Jane has one, she'll search her cache for this domain name.  If Jane finds it she'll get back to us straight away with the desired IP address. Otherwise Jane will strip the host from the domain name and search her cache for a server with authority over the remaining name: &lt;code&gt;wikipedia.com&lt;/code&gt;. If Jane find this server's IP in her cache she'll send our original request-“Can you tell me the IP address of www.wikipedia.org?”- to this server.  For now, lets assume Jane's cache doesn't contain 'wikipedia.com'.  Then Jane will again search her cache for the server with authority over the &lt;code&gt;com&lt;/code&gt; domain.  (Notice that each time the authoritative DNS server strips of the leftmost word off the domain name.)  Finally, if Jane doesn't find this server's IP, she'll resort to contacting the &lt;strong&gt;DNS Root Servers&lt;/strong&gt;.  Root servers are the Authoritative DNS Servers which reside at the top of the heiarchy, right above above top level DNS servers.  &lt;em&gt;(Cache servers, like Jane, are pre-configured with a list of root servers so that they always have someone to contact.)&lt;/em&gt; In this case the root server would respond with a list of server IPs of the &lt;code&gt;com&lt;/code&gt; domain.  Jane would then contact one of the servers from this list, and ask it to resolve &lt;code&gt;www.wikipedia.com&lt;/code&gt;.  The &lt;code&gt;com&lt;/code&gt; DNS server would give Jane some IPs of DNS servers with authority over the &lt;code&gt;wikipedia.com&lt;/code&gt; domain.  Jane could then contact one of these servers, any of which could resolve &lt;code&gt;www.wikipedia.com&lt;/code&gt;.  When Jane finally gets the translation she sends us back our desired IP address.  Jane will also keep (at least temporarily) a cache of the IP addresses that were just discovered: IPs of &lt;code&gt;com&lt;/code&gt; domain servers, &lt;code&gt;wikipedia.com&lt;/code&gt; domain servers and the IP address of &lt;code&gt;www.wikipedia.com&lt;/code&gt;.  The following picture demontstrates this process:&lt;sup id="fnref:5"&gt;&lt;a class="footnote-ref" href="#fn:5" rel="footnote"&gt;5&lt;/a&gt;&lt;/sup&gt;&lt;/p&gt;
&lt;p&gt;&lt;img alt="Pelican" src="../images/example_lookup.png" /&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Cool Trick: you can actually bypass the whole Domain Name Resolution Process by typing in the IP address of the computer you wish to communicate with.&lt;/em&gt;&lt;/p&gt;
&lt;h2&gt;Routing&lt;/h2&gt;
&lt;p&gt;Once we know the IP address of the computer we want to talk to, how does our request make its way to that computer?  &lt;/p&gt;
&lt;p&gt;The answer, is &lt;strong&gt;routers&lt;/strong&gt;.  Routers connect&lt;/p&gt;
&lt;p&gt;Routers are connected between networks to control the flow of messages between them. The main responsibilitis of a router are to ensure messages get sent where they are intended, and to ensure messages don't get sent into networks where they weren't intended.  But how does it do this?  &lt;/p&gt;
&lt;p&gt;Well, each router usually knows about the IP addresses within its sub-networks but not about the IP addresses in networks above it (similar to the DNS system!).  At a high level, we can imagine that a request arrives at its destination IP address by first travelling up this hierarchy of routers until a router that knows about the destination's IP address is reached. At this point the request would begin to travel back down the chain in the direction of the desired computer. &lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Although this gives us a nice idea of how routing works, in reality there's a bit more to it.&lt;/strong&gt; The picture I painted seems to imply that the computer at the ‘top’ of this chain is all knowing -i.e. it knows all the IP addresses of every computer below it- and that is not the case. Each router has a configuration table which lists patterns of IP addresses, and rules to follow based on those patterns. The router will scan the destination address and match that IP address against the patterns in its table. When the router finds the category that the IP fits into, it follows the related instructions to go in a specific direction. Before actually sending out information in this direction, the router will check to see if that direction is satisfactory (i.e. flow is OK there, and nothing seems broken). If all is well it will go ahead. Otherwise it will check the configuration table for an alternate route. Because many different routes exist between two computers on the internet, a request made to google.com one minute might take a completely different route than the next minute. And that's part of the beauty of routing, is that its adaptable and can act accordingly.&lt;/p&gt;
&lt;p&gt;In order for routers to do their job, they are also performing &lt;strong&gt;Network Address Translations&lt;/strong&gt; (NAT).  Remember last time how I mentioned that your personal computer's public IP is your router's IP?  Well, your router has to translate all of the traffic coming from your local network, re-addressing it with its own IP address.  Then the router has to keep track of which incoming messages (all of which are addressed to &lt;em&gt;its&lt;/em&gt; IP address!) are meant for which computer in its local Network.  Even more complicated, routers may have to deal with situations where a private IP in your local network overlaps with a public IP address somewhere in the internet.  In some cases this might cause issues, but other times your router may successfully create a 'lookup table' to keep track of which computer is which, and translate IP addresses to compensate.&lt;/p&gt;
&lt;h3&gt;Thanks Again&lt;/h3&gt;
&lt;p&gt;Well, thats it (for now!) on how the internet works.  I hope that if you've made it this far you've enjoyed the journey.  As always, feel free to reach out to me if you have any questions!  I am no expert, but if there's something I can help you understand I'd be happy to do so!&lt;/p&gt;
&lt;div class="footnote"&gt;
&lt;hr /&gt;
&lt;ol&gt;
&lt;li id="fn:1"&gt;
&lt;p&gt;URL stands for Uniform Resource Locator and refers to the web address used to locate a web page on the World Wide Web.&amp;#160;&lt;a class="footnote-backref" href="#fnref:1" rev="footnote" title="Jump back to footnote 1 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id="fn:2"&gt;
&lt;p&gt;The word &lt;em&gt;distributed&lt;/em&gt; in this context just means that the database is stored over many computers, as opposed to a single database on a single computer.  &amp;#160;&lt;a class="footnote-backref" href="#fnref:2" rev="footnote" title="Jump back to footnote 2 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id="fn:3"&gt;
&lt;p&gt;Of course, you can override this setting if you'd like to use some other Domain Name System Server.&amp;#160;&lt;a class="footnote-backref" href="#fnref:3" rev="footnote" title="Jump back to footnote 3 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id="fn:4"&gt;
&lt;p&gt;A &lt;strong&gt;cache&lt;/strong&gt; is just a fancy word for data that is stored on a machine.  Usually this data is the result of a computation or process that it previously performed, so that if it needs the result again it can provide it more quickly. &amp;#160;&lt;a class="footnote-backref" href="#fnref:4" rev="footnote" title="Jump back to footnote 4 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id="fn:5"&gt;
&lt;p&gt;I got this great image from the wikipedia page on the Domain Name System.  You can find it &lt;a href="https://en.wikipedia.org/wiki/Domain_Name_System#/media/File:An_example_of_theoretical_DNS_recursion.svg"&gt;here&lt;/a&gt;.&amp;#160;&lt;a class="footnote-backref" href="#fnref:5" rev="footnote" title="Jump back to footnote 5 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;</summary><category term="Web"></category></entry><entry><title>How the Internet Works</title><link href="http://lmontopo.github.io/how-the-internet-works.html" rel="alternate"></link><updated>2015-09-10T05:00:00-04:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2015-09-10:how-the-internet-works.html</id><summary type="html">&lt;h2&gt;What is the internet?&lt;/h2&gt;
&lt;p&gt;One thing I’d like to clarify right off the bat is that when we connect to the internet we are connecting to other physical computers.  Any service accessed through the internet- email, Skype, reading the news online- is the result of obtaining data from one or more physical computers.  The internet isn’t some magical entity where resources appear out of thin air.  Indeed, files saved on an online storage system are physically stored on one or more physical computer somewhere in the world. Those of you who already knew this might find it silly of me to point this out, but I’m sure that there are people out there who have this misconception - I used to be one of them.&lt;/p&gt;
&lt;p&gt;In order to understand the structure of the internet, we'll begin by talking about computer networks in general.&lt;/p&gt;
&lt;h3&gt;Types of Networks&lt;/h3&gt;
&lt;p&gt;Different types of computer networks can be classified by size. Lets start with the smallest and work our way up to the largest - the internet:  &lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;The smallest type of network is a &lt;strong&gt;Personal Area Network&lt;/strong&gt; (PAN).  A good example of this type of network is the use of bluetooth. In a personal area network computers are interacting with each other over a very short distance. &lt;/li&gt;
&lt;li&gt;The second smallest type of network is a &lt;strong&gt;Local Area Network&lt;/strong&gt;, or LAN.  These networks span the area of a house, or a few floors of an office building.  As an example: consider how the computers in an office building are often all connected to the same printer.   Another example of the use of a LAN would be you pinging &lt;sup id="fnref:1"&gt;&lt;a class="footnote-ref" href="#fn:1" rel="footnote"&gt;1&lt;/a&gt;&lt;/sup&gt; your co-workers computer when you’re both in the office.  The 'ping' would travel from your computer to your office's router&lt;sup id="fnref:2"&gt;&lt;a class="footnote-ref" href="#fn:2" rel="footnote"&gt;2&lt;/a&gt;&lt;/sup&gt; and then to your coworker's computer.  &lt;/li&gt;
&lt;li&gt;At a larger scale we have &lt;strong&gt;Metropolitan Area Network&lt;/strong&gt; (MAN) which can span the distance of a few blocks or the entire city.  An example of a MAN would be the network of computers that are serviced by a particular Internet Service Provider (ISP) within the city of Toronto.  Indeed all of the modems which provide the LANs with internet, are connected to each other through Internet Exchange Points (IXPs) within the city.&lt;/li&gt;
&lt;li&gt;Anything larger than a MAN is considered to be a &lt;strong&gt;Wide Area Network&lt;/strong&gt;, or WAN. The largest WAN is the internet, connecting computers all over the earth.  &lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The internet can be thought of as a compilation of some of these smaller networks.  One might call it a 'network of networks'. &lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Let's walk through some of the networks I'm connected to when I access the internet from my apartment in Toronto.&lt;/strong&gt;  At the smallest level I'm connected to my LAN through my router.  This router communicates with my modem which allows me access to the city-wide network of computers serviced by my internet provider, a MAN.  Then, all of the internet providers within Toronto connect to each other at IXPs to create an even larger MAN.  And all of these large MANs accross the globe connect to one another through various IXPs, creating what we call the internet!  The following image &lt;sup id="fnref:3"&gt;&lt;a class="footnote-ref" href="#fn:3" rel="footnote"&gt;3&lt;/a&gt;&lt;/sup&gt; serves as a good visual depiction of the internet as a network of networks:&lt;/p&gt;
&lt;p&gt;&lt;img alt="Pelican" src="../images/lan_man_wan.jpg" /&gt;&lt;/p&gt;
&lt;h3&gt;Physically how are computers connected?&lt;/h3&gt;
&lt;p&gt;Sometimes transmission happens wirelessly, other times it happens through physical wires. 
Bluetooth and wifi are examples of a wireless network connections.  In these situations radio signals are used to carry data from one computer to the next.  Most of these wireless networks happen over very short distances.  Between cities and countries and continents, computers are usually connected through wires.  Yes, &lt;em&gt;wires are literally in the ocean, connecting continents so that we can chat to people across the globe.&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;Cool. Now we have an idea of what the internet &lt;em&gt;is&lt;/em&gt;.  It is a network of computer networks connecting computers accross the globe.  These connections can be wireless or through wires.  But &lt;em&gt;how&lt;/em&gt; does it work?&lt;/p&gt;
&lt;h2&gt;How is data transmitted?&lt;/h2&gt;
&lt;p&gt;How do computers understand each other?  How does a message get to the appropriate computer? Introducing... the protocol stack!&lt;/p&gt;
&lt;h3&gt;The Protocol Stack&lt;/h3&gt;
&lt;p&gt;A &lt;strong&gt;protocol&lt;/strong&gt; is just a set of rules that computers obey when they exchange data.  Every type of communication that occurs over the internet uses a set of protocols specified by its corresponding protocol stack.  Different applications (skype, email, etc) may use different protocol stacks.  Here is a diagram depicting the primary layers in the stack: &lt;/p&gt;
&lt;p&gt;&lt;img alt="Pelican" src="../images/protocol_stack.png" /&gt;&lt;/p&gt;
&lt;p&gt;As you can see from the diagram, when data gets sent from Computer 1 to Computer 2, Computer 1 first has to prepare the data for its transmission by going through each of the layers of the protocol stack to add information, package it up, possibly encode or translate it.  When the data is ready, it is passed through the internet from Computer 1 to Computer 2, where the data is unpacked and transformed into its original form.  Lets start from the bottom and work our way up, describing briefly each of these layers.  &lt;/p&gt;
&lt;h4&gt;Hardware Layer:&lt;/h4&gt;
&lt;p&gt;This layer is responsible for translating messages from your computer's native language (in 0s and 1s) to signals that can be transmitted either through wire or radio signals.  Most laptops today have hardware specific for both the ethernet cable and for wifi.  Note that different hardware is required in your computer for each kind of physical connection.  Often the protocol associated with this hardware requires that the unique address on the associated hardware be specified when going from one computer to the next.  This address is called the &lt;strong&gt;Media Access Control address&lt;/strong&gt;, or MAC address.  &lt;/p&gt;
&lt;p&gt;&lt;em&gt;If you are using a Mac OS X (for Linux and Windows see footnote&lt;sup id="fnref:4"&gt;&lt;a class="footnote-ref" href="#fn:4" rel="footnote"&gt;4&lt;/a&gt;&lt;/sup&gt;), you can find your computer's MAC addresses, by typing the following command into your terminal:&lt;/em&gt; &lt;code&gt;$ networksetup -listallhardwareports&lt;/code&gt;.  &lt;em&gt;You should see several different types of hardware appear, including wifi and ethernet, each with their own 'ethernet address'.  This 'ethernet address' is that hardware's MAC address! A couple of my entries look like this:&lt;/em&gt; &lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;Hardware Port: Ethernet
Device: en0
Ethernet Address: 9f:68:90:ce:82:62

Hardware Port: Wi-Fi
Device: en1
Ethernet Address: 70:27:92:c6:db:63
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;h4&gt;Internet Protocol Layer:&lt;/h4&gt;
&lt;p&gt;Every computer on the internet is marked with a ‘unique’ address called an &lt;strong&gt;Internet Protocol address&lt;/strong&gt;, or IP address.  In order for data to move from one computer to the next, it must be labeled with the target IP address and the sender’s IP address.  IP addresses can be split into two categories, &lt;em&gt;public&lt;/em&gt; and &lt;em&gt;private&lt;/em&gt;.   Public IPs are given to every computer ‘visible’ on the internet and are guaranteed to be unique. Private IPs  are given to computers within the same Local Area Network and need only be unique with respect to the other IPs on that network.  When you connect to your wifi at home, your router is acting as your gateway to the internet and your private IP allows your router to distinguish your computer from others on the local network.  &lt;/p&gt;
&lt;p&gt;IP addresses can also be &lt;em&gt;static&lt;/em&gt; or &lt;em&gt;dynamic&lt;/em&gt;.  Static IP addresses are permanent; they don't change.  A computer with a static IP address will have the exact same IP address for the duration of its contract with an Internet Service Provider.  This requires the ISP to effectively &lt;em&gt;reserve&lt;/em&gt; an IP address for a single computer.  In contrast, dynamic IP addresses are temporary in nature.  A computer is re-assigned a dynamic IP address each time it connects to the internet (or, sometimes, even mid-session). Consequently, ISPs can &lt;em&gt;re-use&lt;/em&gt; dynamic IP addresses.  For example, consider the dynamic IP address that is assigned to my computer when I connect to the wifi at a local coffee shop.  This IP address is not reserved for my computer alone, and may be re-assigned to another computer when I leave.  Because they are re-usable, dynamic IP addresses are less costly than static IPs.  Most personal devices will make use of dynamic IPs, while servers usually rely on static IP addresses.&lt;/p&gt;
&lt;h4&gt;Transport Protocol Layer:&lt;/h4&gt;
&lt;p&gt;Among other things, the transport protocol is in charge of labelling which port number on a receiving computer a message is sent to.  You can think of the port as being analogous to specifying a person’s name on a letter to distinguish which person in a house the letter is being sent to.  Since your computer has multiple applications accessing the internet, the port number specifies which application incoming data is meant for. This allows multiple processes to share the same hardware resources without interfering with one another.  Without port numbers, a computer's operating system would have a hard time knowing which application (a web browser, email service) an incoming message was meant for. &lt;/p&gt;
&lt;p&gt;Other responsibilities of the transport layer may include segmentation and desegmentation of the data, ensuring sent data is received, and ensuring it is received in the desired order.&lt;/p&gt;
&lt;h4&gt;Application Level Protocol:&lt;/h4&gt;
&lt;p&gt;Specific to the application, be it email, skype, or the world wide web. In the following example we will discuss the Hyper Text Transfer Protocol (HTTP), which is a popular Application Level Protocol.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Classic Example: Suppose I’m connecting to the internet through my apartment’s wifi and I type www.wikipedia.com into my browser and press enter.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Here the application in use is the world wide web.  The request will be formatted according to the application level protocols specifications (in this case HTTP): &lt;code&gt;HTTP 1.1/ GET wiki/main_page&lt;/code&gt;.  This tells the application on the receiving end that we are using HTTP protocol and that we wish to GET (meaning retrieve) the resource specified.  This message will get passed from our browser (the application) to the computer’s operating system where the transport protocol will do its work.  In this example TCP, Transmission Control Protocol will be used.  When necessary, TCP will split the message into smaller (more manageable) chunks called packets before sending. In this case, each packet will also be labeled so that the receiver knows in which order the packets should be read.  TCP will also attach the port number (in this case 80) to each packet.  Next, the Internet Protocol further packages each packet with the sender and receiver's IP addresses, before handing over control to the hardware/link layer.  This layer wraps the packages with the wifi MAC address on your computer and translates messages into radio signals to be sent to the router.  This message will go from computer to computer, continually unpacked and repackaged by the hardware layers as it travels, until it reaches its destination, where the wiki/main_page resource lives.  The destination computer will translate the message into its native language through the hardware layer.  Then the TCP layer will ensure that each package has arrived (remember that they are labelled) and if one is missing, the computer will send out a request for the missing packet.  If all have arrived, it will place them in order, and send them to the appropriate computer application.  This main wiki page will then be retrieved from the application, and the process of packaging it up for sending will commence.  The resource will be wrapped with the message &lt;code&gt;HTTP 1.1 200 OK&lt;/code&gt; before being split up into manageable chunks, labeled, then repackaged with the IP address of the destination and sender, and further translated and prepared by the hardware layer before being sent out.  When the message finds its way back to our computer, it will be unpacked by each layer until the contents of the message, the wiki/main_page, is provided to our browser to display.&lt;/em&gt; &lt;/p&gt;
&lt;h3&gt;Stay Tuned... Domain Names and Routing!&lt;/h3&gt;
&lt;p&gt;At this point we’ve answered a lot of questions in regards to how the internet works.  But, there’s still a big missing piece of the puzzle, namely, how does my computer know the IP address of the computer we want a resource from, and how does my router know how to navigate to that computer? &lt;/p&gt;
&lt;h4&gt;Thanks&lt;/h4&gt;
&lt;p&gt;Thanks for reading along on this journey to better understand the internet.  There is, of course, still lots of details that I have left out of this discussion, and much that I still have to learn, but I think I've provided enough details to staisfy some itching curiousities.  Don't hesitate to reach out if anything is unclear or if you have any questions!  I can't guarantee I have all the answers, but if I don't, I might be curious as well!  &lt;/p&gt;
&lt;p&gt;Big thanks to &lt;a href="http://individual.utoronto.ca/jnlantos/"&gt;Jasmin Lantos&lt;/a&gt; for studying this topic with me during our 10% time at &lt;a href="https://securitycompass.com/"&gt;Security Compass&lt;/a&gt;! &lt;/p&gt;
&lt;div class="footnote"&gt;
&lt;hr /&gt;
&lt;ol&gt;
&lt;li id="fn:1"&gt;
&lt;p&gt;For anyone unfamiliar with the PING command, try it out!  Simply type &lt;code&gt;ping ip_address&lt;/code&gt; to effectively 'ping' the computer with the corresponding IP address.  You can also ping a server by their hostname. &amp;#160;&lt;a class="footnote-backref" href="#fnref:1" rev="footnote" title="Jump back to footnote 1 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id="fn:2"&gt;
&lt;p&gt;The difference between a router and a modem confsed me at first, so I'm going to take a moment to describe their purposes in your home.  Your router is what allows several computer to connect to the internet simultaneously.  The router is connected to the motem, and the motem is what is needed to gain access to the internet through your Internet Service Provider.  This means that if you only want one computer to have access to the internet at a time in your househole, you only need a motem, not a router. Similarily, if you just wanted to communicate with other computers in your home, and not to other computers in the world, you could just use a router and do away with the motem and the internet service provider.  Sometimes you can buy a box that is both a router and a motem all in one.  &amp;#160;&lt;a class="footnote-backref" href="#fnref:2" rev="footnote" title="Jump back to footnote 2 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id="fn:3"&gt;
&lt;p&gt;This image is adapted from &lt;a href="http://www.gta.ufrj.br/ensino/eel879/trabalhos_vf_2008_2/igorcamp/LAN_MAN_WAN.JPG"&gt;http://www.gta.ufrj.br/ensino/eel879/trabalhos_vf_2008_2/igorcamp/LAN_MAN_WAN.JPG&lt;/a&gt;&amp;#160;&lt;a class="footnote-backref" href="#fnref:3" rev="footnote" title="Jump back to footnote 3 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id="fn:4"&gt;
&lt;p&gt;On a Linux, I have been told that the appropriate command would be &lt;code&gt;ifconfig -a&lt;/code&gt; and that the number next to &lt;code&gt;HWaddress&lt;/code&gt; corresponds to the MAC address.  On a Windows operating system, I beleive one needs to type &lt;code&gt;getmac /v&lt;/code&gt; into the prompt.  Unfortunately I haven't been able to try these commandsn myself, so please let me know if they do not work! &amp;#160;&lt;a class="footnote-backref" href="#fnref:4" rev="footnote" title="Jump back to footnote 4 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;</summary><category term="Web"></category></entry><entry><title>News, Updates and Getting Momentum Again!</title><link href="http://lmontopo.github.io/news-and-updates.html" rel="alternate"></link><updated>2015-07-12T00:00:00-04:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2015-07-12:news-and-updates.html</id><summary type="html">&lt;p&gt;Hello again, Internet People!  Lets start with some news and updates!&lt;/p&gt;
&lt;h3&gt;Hacker School is now The Recurse Center&lt;/h3&gt;
&lt;p&gt;This is kind of 'old' news, but since I went AWOL for a while, I'm only now making the announcement to the world.  For now, I am going to leave my old blog posts that mention Hacker School as is, but in the future I hope to go back and change them.  Going forward, I will use 'The Recurse Center' exclusively.&lt;/p&gt;
&lt;p&gt;For anyone who would like more information about The Recurse Center or about the name change, check out these links: &lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="https://www.recurse.com/"&gt;www.recurse.com&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.recurse.com/blog/77-hacker-school-is-now-the-recurse-center"&gt;www.recurse.com/blog/77-hacker-school-is-now-the-recurse-center&lt;/a&gt; &lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;I'm working at Security Compass&lt;/h3&gt;
&lt;p&gt;After a few months of job searching this winter, I landed a position as a paid intern at a &lt;a href="http://securitycompass.com/"&gt;Security Compass&lt;/a&gt; in Toronto.  I am a little over 3 months into the position, and I have signed a contract to become a permanent Junior Dev starting in August! I am excited to be staying with them, and I look forward to the challenges to come! &lt;/p&gt;
&lt;p&gt;I want to take a quick moment here to thank The Recurse Center for all of the support it offered me during the job search process.  I found much support and advice from the facilitators as well as from other recurse center participants, and for that I am really grateful.  Thank you.  &lt;/p&gt;
&lt;h3&gt;Building Momentum&lt;/h3&gt;
&lt;p&gt;The move and the internship have been the primary reasons for my blogging leave of absence.  Initially, with all these changes in my life, I needed more rest than usual and so I took a break from blogging.  But then as time passed I found it was increasingly harder to get back into writing.  Despite the &lt;em&gt;plethora&lt;/em&gt; of articles I had buzzing in my head demanding to be written, procrastination always seemed to win.  And in the rare moments when I actually managed to write something, I often couldn't find the time to 'perfect' my work and so perfectionism silenced me from publishing it.&lt;/p&gt;
&lt;p&gt;This blog post is my attempt to battle perfectionism and procrastination.  I hope that with this imperfect blog post, I can get the ball rolling again, and build the momentum to start writting on a somewhat more regular basis again.  &lt;/p&gt;
&lt;p&gt;Ciao!&lt;/p&gt;</summary><category term="Life"></category><category term="The Recurse Center"></category></entry><entry><title>Interviews are oportunities to learn</title><link href="http://lmontopo.github.io/interviews.html" rel="alternate"></link><updated>2015-01-29T05:00:00-05:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2015-01-29:interviews.html</id><summary type="html">&lt;p&gt;Over the past month I've had my first experience interviewing for development positions.  Its been a somewhat nerve-racking experience but also, at times, enjoyable.  I've come to realize that the best way to approach an interview is with an attitude of excitement and an openness to learn.&lt;/p&gt;
&lt;p&gt;A couple days before my first 'technical' interview I was feeling pretty overwhelemed.  Tom, a Hacker School facilitator, reminded me that &lt;strong&gt;its public knowledge that I haven't been programming forever&lt;/strong&gt;.  He continued to explain that its OK I don't know everything, and that I'm not expected to.  This was exactly the reminder I needed to hear. Of &lt;em&gt;course&lt;/em&gt; I don't know everything.  I'm just starting out in this field!  Sonali suggested I have fun with my interviews and that I view them as opportunities to learn.  &lt;/p&gt;
&lt;p&gt;Their words of wisdom have really helped me make the most of my interviews. When I stopped putting pressure on myself to be something I'm not (an experienced programmer who knows everything) I could relax, be open to learning, and be genuinely engaged in conversations about programming.  Regardless of whether or not they lead to a job, I am counting my interviews thus far to be a success because of the way I handled them.  I was genuine, I had fun, and I learned cool things.  Win.&lt;/p&gt;
&lt;p&gt;On that note, here's a neat Python thing I learned during a recent technical interview&lt;sup id="fnref:*"&gt;&lt;a class="footnote-ref" href="#fn:*" rel="footnote"&gt;1&lt;/a&gt;&lt;/sup&gt;: &lt;/p&gt;
&lt;h4&gt;A Python Function's Default Arguments Are Mutable:&lt;/h4&gt;
&lt;p&gt;Without running the python code, guess what the following lines would return in an interactive Python interpreter.  (Actually try to guess them before reading my answer! I've added a blank line where you should be guessing):&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[]):&lt;/span&gt;
&lt;span class="o"&gt;...&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="o"&gt;...&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;test&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;

&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;test&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt; 

&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;d&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;test&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;d&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Have you guessed yet?!
... &lt;/p&gt;
&lt;p&gt;My guess was &lt;code&gt;[1]&lt;/code&gt;, &lt;code&gt;[1]&lt;/code&gt;, &lt;code&gt;[1,1]&lt;/code&gt; but the correct answer is &lt;code&gt;[1]&lt;/code&gt;, &lt;code&gt;[1,1]&lt;/code&gt;, &lt;code&gt;[1,1,1]&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;What does all of this mean and what does it tell us about the way Python handles default arguments?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;It means that the default argument binding&lt;sup id="fnref:%"&gt;&lt;a class="footnote-ref" href="#fn:%" rel="footnote"&gt;2&lt;/a&gt;&lt;/sup&gt; happens at the function's &lt;em&gt;definition&lt;/em&gt; not at the function's &lt;em&gt;execution&lt;/em&gt;.  In other words, the statement &lt;code&gt;a = []&lt;/code&gt; is evaluated when the function definition statement is executed, but not when the function is called and its body is executed.&lt;/p&gt;
&lt;p&gt;Lets dig a little deeper.  Recall that in Python everything, including functions, is an object. When a function definition is executed a new function object is created.  This function object will have an attribute called &lt;code&gt;func_defaults&lt;/code&gt; that contains the values of the default arguments.  &lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;test&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;func_defaults&lt;/span&gt;
&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;],)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Like usual object attributes, func_defaults can be mutated.  In our example, the default argument is mutated when the body of the function is executed. Since the line of code that sets func_defaults to &lt;code&gt;[]&lt;/code&gt; is run only when the object is instantiated, these mutations affect the default value for subsequent calls on the function. &lt;/p&gt;
&lt;p&gt;I hope this makes sense!  Feel free to ask questions if it doesn't. :) Also, some useful resources can be found &lt;a href="http://stackoverflow.com/questions/1132941/least-astonishment-in-python-the-mutable-default-argument"&gt;here&lt;/a&gt; and &lt;a href="http://effbot.org/zone/default-values.htm"&gt;here&lt;/a&gt;.  &lt;/p&gt;
&lt;p&gt;And to anyone out there currently undergoing interviews: Try to have fun.  Above all else, be yourself.  You are already impressive.&lt;/p&gt;
&lt;div class="footnote"&gt;
&lt;hr /&gt;
&lt;ol&gt;
&lt;li id="fn:*"&gt;
&lt;p&gt;The interviewer agreed that I could write about his question! :)&amp;#160;&lt;a class="footnote-backref" href="#fnref:*" rev="footnote" title="Jump back to footnote 1 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li id="fn:%"&gt;
&lt;p&gt;Arugment 'binding' is just a fancy way of specifying that a variables name (ex. &lt;code&gt;a&lt;/code&gt;) gets assigned to a peice of data (ex. &lt;code&gt;[]&lt;/code&gt;).&amp;#160;&lt;a class="footnote-backref" href="#fnref:%" rev="footnote" title="Jump back to footnote 2 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;</summary><category term="Python"></category></entry><entry><title>Some things I learned when my computer crashed.</title><link href="http://lmontopo.github.io/some-things-i-learned-when-my-computer-crashed.html" rel="alternate"></link><updated>2014-12-31T00:00:00-05:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-12-31:some-things-i-learned-when-my-computer-crashed.html</id><summary type="html">&lt;p&gt;During my last two weeks at Hacker School I encountered some serious troubles with my computer.  Despite becoming overly emotional about the state of my computer, I learned some valuable things through this experience.  I learned some cool bash commands when &lt;a href="http://rodarmor.com/"&gt;Casey&lt;/a&gt; helped me try to diagnose the cause of my computer's distress.  Then, when my computer was unusable, I spent some time reading a bit about bash and I used Casey's to set up my first ssh account! Finally, when I got my computer back in good health, I learned some lessons about good documentation practices and backing things up.  In this blog post I'll write about some of these things I've learned.&lt;/p&gt;
&lt;h4&gt;Bash Commands:&lt;/h4&gt;
&lt;p&gt;When Casey and I first realized my computer was abnormally slow we set out to do some investigating.  We used some bash commands to see what processes were running and what system calls were being made.  Our hope was that we might detect a particular call that my computer was stuck on.  We didn't have much success with our investigation, but it was still super cool peaking behind the scenes!  Our experimentation also make me eager to learn more about the command line. So, while my computer was away being fixed, I spent some time reading more about bash. Here are some of the bash commands I've learned:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;$ ps aux&lt;/code&gt; : shows all current processes being run.  This is one of the commands Casey taught me while we were playing detective! &lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;$ dtruss -p PID&lt;/code&gt; :  Another one that Casey taught me.  When dtruss is called on a particular process (here i'm specifying the process by its PID, or "process ID"), your computer will show you all of the system calls that are happening for that process.  If you want, you can also look up the man pages for these system calls to figure out what is happening.  Very cool stuff!&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;$ cal&lt;/code&gt; : This one is kind of just for fun.  If you aren't familiar with this command, try it out! &lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;$ say something&lt;/code&gt; :  This one is also just for fun.  The word 'something' can be replaced with whatever you want. &lt;a href="http://todayincode.tumblr.com/"&gt;Cerek&lt;/a&gt; taught me this command when he made his computer sing rap lyrics. &lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;$ chmod&lt;/code&gt; : changes the reading, writing and executing permissions of a file.  I read about this from a book, and then two days later I needed to use this command! I'll talk more in detail about this command in the next seciton. &lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;$ sudo&lt;/code&gt; :  This is a command that I've been using for a while without fully understanding it.  What I understood was that to call certain commands we must first call &lt;code&gt;sudo&lt;/code&gt; and provide our password.  While this is true, it misses the big picture of what sudo &lt;em&gt;does&lt;/em&gt;.  Sudo's man page provides a rather good explanation of the command: "&lt;strong&gt;sudo&lt;/strong&gt; allows a permitted user to execute a command as the superuser&lt;sup id="fnref:1"&gt;&lt;a class="footnote-ref" href="#fn:1" rel="footnote"&gt;1&lt;/a&gt;&lt;/sup&gt; or as another user". In fact, &lt;code&gt;sudo another_user&lt;/code&gt; can be called to carry out a command as if you were 'another_user'. The superuser is the default user when no other user is specified.  So, calling &lt;code&gt;sudo&lt;/code&gt; with no other argument will allow me to call commands as if I were the superuser, thus giving me extra privileges.  &lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;$ alias alias_name="command"&lt;/code&gt; : creates an alias for the command!  An &lt;strong&gt;alias&lt;/strong&gt; is a shortcut for other bash commands.  A useful tutorial (with examples!) on this topic can be found &lt;a href="https://www.digitalocean.com/community/tutorials/an-introduction-to-useful-bash-aliases-and-functions"&gt;here&lt;/a&gt;.  With &lt;a href="http://www.zephyrizing.net/"&gt;Geoff&lt;/a&gt;'s help I made my very first alias for a really ugly looking git command.  Here it is:  &lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="nv"&gt;$ &lt;/span&gt;&lt;span class="nb"&gt;alias &lt;/span&gt;&lt;span class="nv"&gt;gr&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;&amp;quot;log --graph --full-history --all --color --pretty=tformat:%x1b&lt;/span&gt;
&lt;span class="s2"&gt;[31m%h%x09%x1b[32m%d%x1b[0m%x20%s%x20%x1b[33m(%an)%x1b[0m -n15&amp;quot;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Now I can just type &lt;code&gt;git gr&lt;/code&gt; into my command line to produce a pretty graphical representation of my git log.  Great! &lt;/p&gt;
&lt;h4&gt;What is SSH?&lt;/h4&gt;
&lt;p&gt;Throughout hacker school I had heard the term "ssh" come up in conversation a few times, but I never paused to ask about it.  That is, until &lt;a href="http://www.flowerhack.com/"&gt;Julia&lt;/a&gt; set up an ssh server on "www.hackers.cool" and invited us to all get accounts! So, I learned some stuff about ssh, I set up a hackers.cool account on Casey's computer, and, once I got my computer back from the repair shop, I transfered my account from Casey's computer to my own. Here's are some things I learned:&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;SSH&lt;/strong&gt; stands for secure shell.  As far as I understand this specifies a protocol by which 'clients' can log onto a server computer remotely through a command line interface.  For me, setting up my own hackers.cool account helped me understand what this really meant.  I got to see how typing &lt;code&gt;ssh leta@hackers.cool&lt;/code&gt; into my terminal would remotely connect me to the harckers.cool server.  Here are some of the cool things I observed:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Other users could write messages in the terminal like &lt;code&gt;banner Hello&lt;/code&gt; or &lt;code&gt;echo Hey!&lt;/code&gt;, and they would appear on my terminal too!  This makes sense because we were all remotely connected to the &lt;em&gt;same&lt;/em&gt; server.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;I made changes to my hackers.cool user home page. This homepage is specified by a file on the &lt;em&gt;remote&lt;/em&gt; computer and I was changing this file from &lt;em&gt;my&lt;/em&gt; computer.  I could even check out my homepage on hackers.cool for proof that the changes actually occured. This was an exciting experience for me. &lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Another cool thing I could do was type 'irc', which stands for internet relay chat.  This brings me to a an old school style chat room with other hackers.cool clients! &lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;How I set up my hackers.cool account&lt;/strong&gt;:&lt;br /&gt;
On www.hackers.cool you can click on "sign up here" for instructions.  It will ask you for a username and will ask you to provide a public ssh key. I like &lt;a href="https://help.github.com/articles/generating-ssh-keys/"&gt;Github's&lt;/a&gt; simple description of an SSH key as "a way to identify trusted computers without involving passwords".  I'm not exactly sure how they work, but some sort of cryptogrophy is involved for security.  I'd like to find out more about them. &lt;/p&gt;
&lt;p&gt;&lt;strong&gt;How did I transfer my account from Casey's computer to my own?&lt;/strong&gt;&lt;br /&gt;
At some point I had to figure out how to transfer my hackers.cool account from Casey's computer to my own. Since the ssh key associated with my account was on Casey's computer and not my own, something needed to be done before I could log in from my own computer. So, I grabbed a USB stick and moved the .ssh directory onto my computer.  I still wasn't able to log into hackers.cool.  When I tried to I got an error message.  I don't remember exactly what the error message was, but it said something about the permissions of files in my .ssh directory not being secure enough.  It seemed to me that the permissions of these files must have changed during the transfer from Casey's computer to my own.  So, I used &lt;strong&gt;chmod&lt;/strong&gt; to change them!  Here are the details: &lt;/p&gt;
&lt;p&gt;&lt;strong&gt;How I used chmod&lt;/strong&gt;:     &lt;br /&gt;
I used the command &lt;code&gt;chmod 700 file&lt;/code&gt; for both files within my .ssh directory.  The number 7 signifies permission to read, write ane execute.  The number 0 specifies no permissions at all. The first digit refers to the user's permissions, the second digit to the 'groups' permissions, and the third to the world.  So by specifying 700, I gave the user reading, writing and executing permissions but gave no permissions to anyone else. The next time I tried to log in with "ssh leta@hackers.cool" I was successful! (The &lt;a href="http://en.wikipedia.org/wiki/Chmod"&gt;wikipedia page&lt;/a&gt; gives a more thorough description of how chmod can be used.)&lt;/p&gt;
&lt;h4&gt;Tips about Pip:&lt;/h4&gt;
&lt;p&gt;It can actually be super helpful to keep track of any dependencies for a particular project.  I realized this when my computer crashed and none of my git repos included any meta-data about their dependencies. In the future I'm going to use this very easy way to keep track of my python dependencies for each project: &lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;First, setup a virtual environment for each project, with all of the dependencies installed in this virtual environment.  If this is my setup, then &lt;code&gt;pip freeze&lt;/code&gt; will produce a list of all the pip packages installed for this project. (Note:  without a virtual environment for each project, &lt;code&gt;pip freeze&lt;/code&gt; would simply produce a list of ALL dependencies for ALL projects.) &lt;/li&gt;
&lt;li&gt;Make a requirements page by typing: &lt;code&gt;pip freeze &amp;gt;&amp;gt; requirements.txt&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Include the requirements page in my remote repo!&lt;/li&gt;
&lt;li&gt;When I want to run a project on another computer I can run &lt;code&gt;pip install -r requirements.txt&lt;/code&gt; and all of the documented packages will be install by pip! Easy!  &lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;Documenting Your Workflow and Backing Things Up&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;Include source files in your github repo!&lt;/strong&gt;
When my computer crashed and I wanted to write a blog post from Casey's computer, it occured to me how much it sucked that I only saved my html output, and not my source files of my blog.  With the help of some awesome hackerschoolers, I was able to retreive some old files and get things back up and running.  But, the whole process would have been a lot smoother had I simply included my markdown files in my github repo! &lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Add a README with your workflow!&lt;/strong&gt;
Once I had Casey's computer all set up for me to work on my blog, I added a README file to my github repo, speciying my workflow.  This ended up helping me dramatically once I got my own computer back.  Sometimes in the moment I think "oh, I'll remember my workflow".  But maybe I won't!  It's worth taking a minute to include a readme with your workflow, in case you don't remmeber it. :) &lt;/p&gt;
&lt;p&gt;And generally.... &lt;strong&gt;Back things up.&lt;/strong&gt;&lt;/p&gt;
&lt;div class="footnote"&gt;
&lt;hr /&gt;
&lt;ol&gt;
&lt;li id="fn:1"&gt;
&lt;p&gt;The superuser is a fairly new concept to me, but this is what I understand so far: A superuser is a user on a computer that has all the special privileges used for system administration.  Different operating system's have different names for the superuser.  This is not a user that you create  yourself on your computer, it is there without you doing anything.&amp;#160;&lt;a class="footnote-backref" href="#fnref:1" rev="footnote" title="Jump back to footnote 1 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;</summary><category term="Bash"></category><category term="Documentation"></category></entry><entry><title>Scopes got me again!</title><link href="http://lmontopo.github.io/scopes-got-me-again.html" rel="alternate"></link><updated>2014-12-15T00:00:00-05:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-12-15:scopes-got-me-again.html</id><summary type="html">&lt;p&gt;In a previous blog post I wrote about some of the struggles I encountered with scoping when Margo and I worked on our web framework Chapeau.  This week, scopes got me again!  This time, while I was working on my Template Engine. &lt;/p&gt;
&lt;p&gt;I think that, as a new programmer, its not totally surprising that I've been a bit naive and carefree about scopes and global variables.  However, I think that making mistakes was a good way for me to learn.  Having been tricked by scoping issues twice now, I'll be much more careful with these matters in the future.  &lt;/p&gt;
&lt;p&gt;In this blog post I'm going to present a peice of code I wrote as an example.  It illustrates in a straightforward manner the issues I was facing with my Template Engine.  After presenting the code, I'll explain what is problematic about it. I'll present some examples tests I wrote for it, I'll show the weird things that the tests were doing, and I'll explain what I initially thought was happening and what I learned was &lt;em&gt;actually&lt;/em&gt; happening. &lt;/p&gt;
&lt;p&gt;Here's the example file which I've named string_maker.py&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;HTMLString&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt;

    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;update&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;html_text&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;html_text&lt;/span&gt;

&lt;span class="n"&gt;my_HTML&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;HTMLString&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;add_to_string&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;my_HTML&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;update&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;First the class HTMLString is defined with attribute 'value', initially set to be the empty string.  This class also contains a method, update, which adds an inputed string to the end of value.  An instance of this class called my_HTML is created and a function, 'add_to_string()', is defined.  This function basically turns some input into a string format and calls my_HTML's update method on that string. &lt;/p&gt;
&lt;p&gt;This code is pretty simple and it does a satisfactory job of concatinating more characters to the end of an existing string.  But notice that only one string is ever being added to.  Indeed, we only have one instance of the StringHTML class.  If we wanted this program to produce two different strings, well it can't (or at least I don't think it can in its current state).  This isn't really an issue unless, say, this code was part of a larger program intended to work as a template engine...  So consider for a moment that the strings we are creating in this program are HTML pages.  Perhaps these webpages will be sent back to a web-app which wants multiple web-pages.  If more than one HTML page is being created, then our program would have to terminate, and then start up again, in between HTML pages.  That's not really ideal.  &lt;/p&gt;
&lt;p&gt;Since my Template Engine has code that is similar to string_maker.py, we can already can see that I wasn't going about things in the smartest way.  I did realize this at some point but I wanted to get some working tests up and running before improving my code.mSo lets write some tests for string_maker.py!  I started with this:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6
7
8&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="nn"&gt;string_maker&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="nn"&gt;unittest&lt;/span&gt; 

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;TestMain&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;unittest&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;TestCase&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;

    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test_simple&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;add_to_string&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;Hey!&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assertEqual&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;my_HTML&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;Hey!&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;And received this lovely little message back:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;Ran 1 test in 0.000s

OK
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Gotta love that!&lt;/p&gt;
&lt;p&gt;Now lets add another test function to this class, and we'll call add_to_string() multiple times in this test to make sure that it will keep updating as we expect.   Here's what we'll add:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test_call_multiple&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;add_to_string&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;One&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;add_to_string&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;two&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;add_to_string&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;three&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assertEqual&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;my_HTML&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;Onetwothree&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;At this point I expect an error.  Afterall, I know that string_maker.py can only create one html page at a time.  So lets run the test and see. &lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;$ python test.py
.F
======================================================================
FAIL: test_class (__main__.TestMain)
----------------------------------------------------------------------
Traceback (most recent call last):
  File &amp;quot;test.py&amp;quot;, line 8, in test_class
    self.assertEqual(my_HTML.value, &amp;#39;&lt;span class="nt"&gt;&amp;lt;html&amp;gt;&lt;/span&gt;Hey!&lt;span class="nt"&gt;&amp;lt;/html&amp;gt;&lt;/span&gt;&amp;#39;)
AssertionError: &amp;#39;&lt;span class="nt"&gt;&amp;lt;html&amp;gt;&lt;/span&gt;Onetwothree&lt;span class="nt"&gt;&amp;lt;/html&amp;gt;&amp;lt;html&amp;gt;&lt;/span&gt;Hey!&lt;span class="nt"&gt;&amp;lt;/html&amp;gt;&lt;/span&gt;&amp;#39; != &amp;#39;&lt;span class="nt"&gt;&amp;lt;html&amp;gt;&lt;/span&gt;Hey!&lt;span class="nt"&gt;&amp;lt;/html&amp;gt;&lt;/span&gt;&amp;#39;

----------------------------------------------------------------------
Ran 2 tests in 0.000s

FAILED (failures=1)
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;A single error, as expected.  What I didn't expect was for the first test, test_simple, to be the failing test!  This lead to a nice lesson about Python Unittests: &lt;strong&gt;Tests do not run in the order that you declare them&lt;/strong&gt;.  Cool! &lt;/p&gt;
&lt;p&gt;At this point I get all naive and think "OK, I can fix this, here's how":&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="nn"&gt;string_maker&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="nn"&gt;unittest&lt;/span&gt; 

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;TestMain&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;unittest&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;TestCase&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;

    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test_simple&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;my_HTML&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;HTMLString&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
        &lt;span class="n"&gt;add_to_string&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;Hey!&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assertEqual&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;my_HTML&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;Hey!&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test_call_multiple&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;my_HTML&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;HTMLString&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
        &lt;span class="n"&gt;add_to_string&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;One&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;add_to_string&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;two&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;add_to_string&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;three&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assertEqual&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;my_HTML&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;Onetwothree&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;I figured, if I just re-instantiate my class inside each function, then my_HTML.value will be whiped clean at the begining of each test.  Problem solved, right?  Wrong....&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="err"&gt;$&lt;/span&gt; &lt;span class="n"&gt;python&lt;/span&gt; &lt;span class="n"&gt;test&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;py&lt;/span&gt;
&lt;span class="n"&gt;FF&lt;/span&gt;
&lt;span class="o"&gt;======================================================================&lt;/span&gt;
&lt;span class="n"&gt;FAIL&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;test_call_multiple&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;__main__&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;TestMain&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="o"&gt;----------------------------------------------------------------------&lt;/span&gt;
&lt;span class="n"&gt;Traceback&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;most&lt;/span&gt; &lt;span class="n"&gt;recent&lt;/span&gt; &lt;span class="n"&gt;call&lt;/span&gt; &lt;span class="n"&gt;last&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
  &lt;span class="n"&gt;File&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;test.py&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;line&lt;/span&gt; &lt;span class="mi"&gt;16&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;test_call_multiple&lt;/span&gt;
    &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assertEqual&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;my_HTML&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;Onetwothree&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="ne"&gt;AssertionError&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;Onetwothree&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;

&lt;span class="o"&gt;======================================================================&lt;/span&gt;
&lt;span class="n"&gt;FAIL&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;test_class&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;__main__&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;TestMain&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="o"&gt;----------------------------------------------------------------------&lt;/span&gt;
&lt;span class="n"&gt;Traceback&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;most&lt;/span&gt; &lt;span class="n"&gt;recent&lt;/span&gt; &lt;span class="n"&gt;call&lt;/span&gt; &lt;span class="n"&gt;last&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
  &lt;span class="n"&gt;File&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;test.py&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;line&lt;/span&gt; &lt;span class="mi"&gt;9&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;test_class&lt;/span&gt;
    &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assertEqual&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;my_HTML&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;Hey!&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="ne"&gt;AssertionError&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;Hey!&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;

&lt;span class="o"&gt;----------------------------------------------------------------------&lt;/span&gt;
&lt;span class="n"&gt;Ran&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt; &lt;span class="n"&gt;tests&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="mf"&gt;0.000&lt;/span&gt;&lt;span class="n"&gt;s&lt;/span&gt;

&lt;span class="n"&gt;FAILED&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;failures&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;AHHH!! WHAT IS HAPPENING!?  My instinct was to think that UnitTests just work in reallly wierd ways that I don't understand.  So I figured I experimented. &lt;/p&gt;
&lt;p&gt;The next thing I tried was this: Instead of re-instantiating HTMLString inside each test function I defined one of UnitTest's magic setUp functions.  When running unit tests, if you define a function called &lt;code&gt;setUp()&lt;/code&gt;, then Python will know to run this function before every other test funciton.  So I made a setUp function to perform &lt;code&gt;my_HTML = HTMLString()&lt;/code&gt;.  And then I got the same errors as I did when I never re-instantiated at all.  Its like my program didn't even run my setUp function at all!  I tried doing the same thing but with a tearDown() function, and again had no luck.  &lt;/p&gt;
&lt;p&gt;I was so confused.  I got my awesome friend &lt;a href="http://programmingforwitches.tumblr.com"&gt;Amanda&lt;/a&gt;'s help, and she suggested that, instead of writing &lt;code&gt;from string_maker import *&lt;/code&gt;, that I just import the functions I needed to run my code.  This was a good idea, but it didn't work either.  Amanda was awesome though, because she asked me all sorts of questions, and those questions helped me realize what I was doing wrong! Here's what I learned:&lt;/p&gt;
&lt;p&gt;When I re-instantiate the &lt;code&gt;my_HTML = HTMLString()&lt;/code&gt; inside each of my test functions, I am creating a local instance of this class.  Local, meaning, in the scope of the function.  Then I call &lt;code&gt;add_to_string&lt;/code&gt; which updates the &lt;em&gt;global&lt;/em&gt; instance of my_HTML (ie. the instance of the class that is in my code string_maker.py)
.  &lt;strong&gt;These are not the same object!&lt;/strong&gt; So I update the global instance, and then assertEqual on the local instance, which of course still have an empty value string. &lt;/p&gt;
&lt;p&gt;If this isn't making sense, remember that when you create a function you create a scope for that function.  When a function encounters a name its not familiar with, it will first check within its own scope, ie within its own definition, to see if there is anything by that name defined there.  If there isn't, then it will look for things outside of its own scope. As soon as it finds something, it uses it.  &lt;/p&gt;
&lt;p&gt;Take Away:  &lt;strong&gt;You can have a local variable and a global variable that have the same name, but they are not the same thing!!!!&lt;/strong&gt; &lt;/p&gt;</summary><category term="Python"></category></entry><entry><title>Regular Expressions in Python - with LOTS of Examples!</title><link href="http://lmontopo.github.io/regular-expressions-in-python-with-lots-of-examples.html" rel="alternate"></link><updated>2014-12-04T05:00:00-05:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-12-04:regular-expressions-in-python-with-lots-of-examples.html</id><summary type="html">&lt;p&gt;Over the past several days I've learned a great deal about regular
expressions. I struggled initially with the subject, but I think things
have finally clicked. So, I'm going to write what I've learned! In this
blog post I am going to:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Explain what a regular expression is.&lt;/li&gt;
&lt;li&gt;Introduce &lt;code&gt;re.split()&lt;/code&gt; and use it to provide examples.&lt;/li&gt;
&lt;li&gt;Explain some of the ways that the star, dot, and question mark can
    be used in a regular expression.&lt;/li&gt;
&lt;li&gt;Explain, in detail, the plague of the backslash.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;As I learned about regular expressions, I found examples to be
enourmously helpful. For this reason, there will be a TON of examples
throughout this blogpost.&lt;/p&gt;
&lt;h4&gt;What is a regular expression?&lt;/h4&gt;
&lt;p&gt;A regular expression is sequence of characters that represent a pattern
we would like to search for within a larger chunk of text. There are two
types of characters within a regular expression: ones that represent
themselves, called &lt;strong&gt;ordinary characters&lt;/strong&gt;, and one's that don't
represent themselves, called &lt;strong&gt;special characters&lt;/strong&gt;. Most common
characters, like the letter 'a', match to themselves in a python regular
expression.&lt;/p&gt;
&lt;h4&gt;Introducing the split function:&lt;/h4&gt;
&lt;p&gt;To use regular expression in Python you need to &lt;code&gt;import re&lt;/code&gt;. This module
gives you access to many different methods. The ones I use the most are
&lt;code&gt;re.split(pattern, string)&lt;/code&gt; and &lt;code&gt;re.match(patter, string)&lt;/code&gt;. I find
&lt;code&gt;re.split()&lt;/code&gt; easiest to understand, so we'll start there. We'll visit
&lt;code&gt;re.search()&lt;/code&gt; later.&lt;/p&gt;
&lt;p&gt;The &lt;code&gt;re.split(pattern, string)&lt;/code&gt; is very similar to python's built in
split method for strings. It splits the inputed string over the pattern
expressed by the regular expression. By default, &lt;code&gt;re.split()&lt;/code&gt; will
return a list of all the parts of the string, excluding the parts that
matched the pattern. If you would like the resulting list to include the
sections which match to the pattern then parenthesis are needed around
the regular expression:&lt;/p&gt;
&lt;h5&gt;Example 1: Introductiory Example:&lt;/h5&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="nn"&gt;re&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;Hackerschool is cool.&amp;#39;&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;a&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;H&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;ckerschool is cool.&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(a)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;H&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;a&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;ckerschool is cool.&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;As you can see, when we put parentheses around 'a', then 'a' is included
in the resulting list. But perhaps we have a pattern that is more than
one character long, and we want only part of the pattern to be kept in
the array. To do this brackets are put around the part of the regular
expression we want to keep. Check it out:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;a(ck)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;H&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;ck&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;erschool is cool.&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Here the 'a' is still left out because it wasn't included in the
parentheses!&lt;/p&gt;
&lt;h4&gt;Special Characters Star, Period and Question Mark:&lt;/h4&gt;
&lt;p&gt;We're going to use &lt;code&gt;re.split()&lt;/code&gt; to explore what these special symbols
match to in a regular expression.&lt;/p&gt;
&lt;h5&gt;Example 2: The period:&lt;/h5&gt;
&lt;p&gt;According to Python's regular expression documentation, the period
matches any character except a newline.&lt;/p&gt;
&lt;p&gt;so as you'd expect it is going to split on every character...&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6
7
8
9&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;Hackerschool is cool!&amp;quot;&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(.)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;H&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;a&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;c&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;k&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;e&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;r&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;s&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;c&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;h&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;o&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;o&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;l&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39; &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;i&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;s&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39; &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;c&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;o&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;o&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;l&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;!&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;It might be surprising to you that there are empty string elements
between each character. I was surprised! I don't really have a good
explanation for why this happens except to say that this is just the way
the split function works. It finds the pattern we are searching for, and
then says "OK, on the left side of this pattern instance we have (fill
in the blank) and on the right side we have (fill in the blank)". In our
example, since every character is an instance of the pattern, on either
side of each pattern instance there is only the empty string. We'll see
another occurence of this behaviour in a later example. If it doesn't
make sense to you now, hopefully it will then.&lt;/p&gt;
&lt;p&gt;Now lets combine the dot with other characters:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(.ool)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Hackersc&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;hool&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39; is &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;cool&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;!&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;This makes sense - there were two occurences where there appeared "some
character followed by 'ool'".&lt;/p&gt;
&lt;p&gt;Lets try a couple more examples just to make sure we get the hang of it:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(c.o)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Hackers&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;cho&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;ol is &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;coo&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;l!&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(c.h)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Hackerschool is cool!&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;The first time we split over 'cho' and 'coo' since both are instances of
the pattern "'c' followed by some character followed by 'o'". The second
time we don't split the expression at all. Even though 'ch' is in
school, there is no character between the 'c' and the 'h'. So 'ch'
doesn't match to the regular expression 'c.h'. The lesson here is that
&lt;strong&gt;'.' on its own matches to exactly one instance of any character&lt;/strong&gt;. Not
zero, not two, one.&lt;/p&gt;
&lt;h5&gt;Example 3: The period and the star.&lt;/h5&gt;
&lt;p&gt;The star represents 0 or more repititions of the previous character
expressed in the regular expression. Whenever possible, the star will
'suck up' as much as it can. Because of this behaviour, star is called a
&lt;strong&gt;greedy character&lt;/strong&gt;.&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;I like reading scify books.&amp;quot;&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(s.i)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;I like reading &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;sci&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;fi books.&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(s.*i)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;I like reading &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;scifi&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;books&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Without the star, the regular expression 's.i' will match to 'sci'. When
the star is added the regular expression matches to more stuff! The
expression 's.*i' matches to 'scifi' because the star indicates that
the dot can be repeated 0 or more times. Because the star is greedy it
soaks up as many repetitions as possible.&lt;/p&gt;
&lt;p&gt;Lets see what happens when we change the text to "I like science
books.".&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;I like science books.&amp;quot;&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(s.*i)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;I like &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;sci&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;ence books.&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Now that there is only one 'i' in the text, there are no more characters
that the star can suck up, so, "s.*i" matches to 'sci'.&lt;/p&gt;
&lt;h5&gt;Example 4: The Question Mark&lt;/h5&gt;
&lt;p&gt;The question matches either 0 or 1 repetitions of the preceeding regular
expression. Here are some examples:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;There are num sections in this document.&amp;quot;&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(e.*)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Th&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;ere are num sections in this document.&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(e.?)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Th&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;er&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;e &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;ar&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;e &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;num s&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;ec&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;tions in this docum&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;en&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;t.&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;When we use the question mark instead of the star there are many more
matches to the regular expression! The question mark is basically the
oposite of a greedy character.&lt;/p&gt;
&lt;p&gt;Also, notice the occurence of an empty string between the 'er' and the
'e'. Since we are splitting over the 'er' and the 'e' the split
functions wants to put something on either side of these that isn't
something else we're splitting over. The only thing between the 'er' and
the 'e' is the empty string. Hopefully this examples helps to understand
the whole empty string phenomenon.&lt;/p&gt;
&lt;h5&gt;Example 5: Combining the dot, star, and question mark:&lt;/h5&gt;
&lt;p&gt;Lets see what happens when we combine all three: the dot, the star, and
the question mark.&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;There are num sections in this document.&amp;quot;&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(e.*?)&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Th&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;e&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;r&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;e&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;ar&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;e&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39; num s&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;e&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; 
&lt;span class="s"&gt;&amp;#39;ctions in this docum&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;e&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;nt.&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Placing the question mark after a the star makes the regular expression
match to the minimal number of characters possible. We'll see this more
in the next example...&lt;/p&gt;
&lt;h5&gt;Example #4: Application to my Template Engine:&lt;/h5&gt;
&lt;p&gt;I have been working on writing my own template engine. In my language,
variables will be contained within double curly braces. I used regular
expressions to parse the html template and find all of the variables.
Lets see an example:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;html_text&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;&amp;lt;html&amp;gt;&amp;lt;title&amp;gt; Hello {{name}}.&amp;lt;/title&amp;gt; Today is {{day}}.&amp;lt;/html&amp;gt;&amp;quot;&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;({{.*?}})&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;html_text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;&amp;lt;title&amp;gt; Hello &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;{{name}}&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;.&amp;lt;/title&amp;gt; Today is &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;{{day}}&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;.&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Just to make sure we understand what the star and question mark are
doing, lets see what happens when either one is removed:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;({{.*}})&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;html_text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;&amp;lt;title&amp;gt; Hello &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;{{name}}.&amp;lt;/title&amp;gt; Today is {{day}}&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;.&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;({{.?}})&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;html_text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;lt;html&amp;gt;&amp;lt;title&amp;gt; Hello {{name}}.&amp;lt;/title&amp;gt; Today is {{day}}.&amp;lt;/html&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;When the question mark is removed, the star acts greedily and soaks
everything up until the last occurence of '}}'. When the star is
removed, we have no match to our pattern at all. This is because the
variable names inside the curly braces are more than 1 character long.&lt;/p&gt;
&lt;h4&gt;The plague of the backslash:&lt;/h4&gt;
&lt;p&gt;Now we have a handle on those special functions, lets explore the ...
dun dun dun... THE BACKSLASH!&lt;/p&gt;
&lt;p&gt;Beleive it or not, the regular expression for a backslash is FOUR
backslashes. Woah. Lets walk through why this is the case:&lt;/p&gt;
&lt;p&gt;In python, a backslash is a special character, and so to represent a
backslash we actually need to use two backslashes. So in python two
backslashes represents one. I'm not even talking about regular
expressions yet, I'm just talking about python strings. Lets verify
this:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;backslash&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;&lt;/span&gt;&lt;span class="se"&gt;\\&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;backslash&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="mi"&gt;1&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="n"&gt;backslash&lt;/span&gt;
\
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Neat!&lt;/p&gt;
&lt;p&gt;Ok, so this means that we actually have to write a regular expression
which will match to two backslashes instead of to a single backslash.
Now, in regular expression land, backlash is one of those special
characters we talked about previously. They don't match to themselves.
The regular expression for a backslash is also two backslashes. So,
since we want to match to the python string &lt;code&gt;\\&lt;/code&gt; the regular expression
to do so becomes &lt;code&gt;\\\\&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;I hope you've enjoyed this introduction to regular expression in Python.
If anything is confusing, don't hesitate to contact me!&lt;/p&gt;</summary><category term="Regular Expressions"></category><category term="Python"></category></entry><entry><title>I made my first cookie!</title><link href="http://lmontopo.github.io/i-made-my-first-cookie.html" rel="alternate"></link><updated>2014-11-27T05:00:00-05:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-11-27:i-made-my-first-cookie.html</id><summary type="html">&lt;p&gt;Margo and I have been working on our web-framework, Chapeau. To test out
its functionality and user-friendliness, we've been using Chapeau to
build various web-apps. This week we implimented a buzz-feed-style quiz.
To challenge ourselves (and Chapeau) we structured the app to have a
separate webpage for each question, and then a final webpage displaying
the result. This forced us to address the issues: 'Does Chapeau allow
data to be transfered between non-adjacent webpages?' and 'Does Chapeau
allow for the data to be accessed directly and used in a calculation'?
As we tried to answer these questions and broaden the functionality of
Chapeau, the framework took on several variations. In this blog post
I'll begin by describing how Chapeau works for very simple web-apps, and
then I'll continue by explaining some of the changes we made to Chapeau
as we worked towards our buzz-feed-style quiz.&lt;/p&gt;
&lt;h4&gt;Simple Web Apps&lt;/h4&gt;
&lt;p&gt;Chapeau's design makes very simple web-apps just that: very simple. To
make such an app, a developer needs only to define a dicitonary matching
URL's to their corresponding html pages. Then calling Chapeau's 'go'
function on the dictionary gets everything going. Pretty simple right?
Beleive it or not, with Chapeau, an app this simple can even pass
variables from an html form to the webpage that follows. The app itself
(by 'app' I mean the python code) does not need to be changed to include
this feature. Adding very basic variable passing to a Chapeau app is
just a matter of formatting your html pages accordingly. Here's how to
do it:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;The form must specify either 'method = get' or 'method = post',
    since Chapeau deals only with post and get requests.&lt;/li&gt;
&lt;li&gt;The form's action needs to specify the URL that this form redirects
    to.&lt;/li&gt;
&lt;li&gt;The html page corresponding to this URL should have '%(key)s'
    wherever this key's value is meant to appear.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;How is this all working? In the background Chapeau parses the request
made from the form's submission. Chapeau finds the user's input in this
request and stores it in a dictionary of key-value pairs called params.
The specified html file is then read in as a string with '%params'
tacked on to the end. Python's built in string formatting takes care of
the rest, and the page renders with the desired arguments! Easy-peasy.&lt;/p&gt;
&lt;p&gt;But what if we wanted to mutate the user input in some way? Or what if
we wanted to &lt;em&gt;use&lt;/em&gt; the input to perform some sort of analysis or
calculation? Perhaps we want to create some results for a quiz? Our
initial version of Chapeau could not handle such situations.&lt;/p&gt;
&lt;h4&gt;Adding Functions&lt;/h4&gt;
&lt;p&gt;To extend Chapeau's usability Margo and I decided that web developers
would have the choice to route a URL to a path or to a function. If a
URL is routed to a function then this function would have a few
structural constraints. Initially, these were the constraints we
implimented:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Chapeau will be passing a dictionary into the function, so the
    function must be defined to accept it. This dictionary will contain
    some of the request information and will look something like:
    '{'type': 'get', 'query': 'query_string', 'path': 'url' , 'body':
    'user_input_from_post_form'}'. (Basically this dictionary stores
    all of the request information except for the headers.)&lt;/li&gt;
&lt;li&gt;The function must return two objects: a path and a dictionary. The
    path will specify the next html page to be rendered and the
    dictionary will be the same one that the function receives, but
    possibly with some mutated data.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The dictionary that the function takes in gives the developer access to
the user input that was just aquired. If the developer wanted to mutate
this user input in anyway, they could do so. Alternatively, if the
developper wants user input to be saved so that it can be obtained
later, Margo and I figured this could be done as well. The developper
could create a global dictionary that they can add to when user input is
submitted, and that they could read from later. Problem solved. Except
not really.&lt;/p&gt;
&lt;p&gt;More experienced developpers might already see the problem we've
created. Consider the buzz-feed-style quiz that Margo and I wanted to
create. Suppose that we implimented this app by storing the user input
in a global dictionary. This dictionary is updated after every question
is answered. When the results page needs to be rendered all of the user
input is obtained from the global dictionary. But suppose two clients,
client1 and client2, are taking the quiz simultaneously. Client1 inputs
their answer to question 1 first, and chooses 'grapes'. Before client1
finishes the quiz client2 submits their answer to question 1 as
'oranges'. When our app goes to fetch the results of client1, their
'grapes' answer will have been overwritten by 'oranges'. Afterall, we've
only implimented one global dictionary for our entire client base. Oups.&lt;/p&gt;
&lt;h4&gt;Finally, adding Cookies!&lt;/h4&gt;
&lt;p&gt;At this point Margo and I weren't really sure how to solve this issue.
How do we keep track of which answer corresponds to which client? For
advice, we turned to our trusted friend
&lt;a href="http://www.greghendershott.com"&gt;Greg&lt;/a&gt; who suggested we use cookies!&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;What is a cookie, and how do I make one?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;A cookie is a very small peice of data that will be sent from a server
and stored temporarily on a client's computer. To create a cookie, the
server needs to include a 'Set-Cookie' header in their HTTP response to
the client. This will prompt the client's browser to create a 'cookie'
to store the specified data. When a browser has a cookie from our server
any HTTP request it sends to us will include a 'Cookie' header
containing the data we asked it to store.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;How does this help our situation?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Margo and I used cookies to store every quiz answer submited from a
client. Then, when the client's browser sends our server an HTTP request
asking for their results page, this request will include all of that
client's quiz answers - stored in the form of cookies! Great!&lt;/p&gt;
&lt;p&gt;Now lets talk about how we implimented this. To create cookies Margo and
I changed the constraints of our functions (the ones that URL's are
routed to) as follows:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Chapeau will now pass to these functions both the dictionary
    containing the request information and a client object. So these
    functions must now accept two parameters! The dicitonary accepted
    contains everything the previous one does, but also includes
    '{header: {all of the headers and their values}}'.&lt;/li&gt;
&lt;li&gt;The functions must call Chapeau's render function: render(client,
    path/to/html/file, args, header) before returning None.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Now that &lt;em&gt;all&lt;/em&gt; of the request information is passed to the developper,
cookies can be read. Since the developer is now also in charge of
calling the render function, they have control over any headers they
want to include in their response. The header parameter in the render
function is optional, and when unspecified it will be set to None. The
args parameter is a dictionary of variables that we want to pass to the
html file. So, in our buzz-feed-style-quiz, every client's answer will
be saved in a cookie. When we want to render the results page all of the
incoming cookies can be read from the inputed dictionary of request
information. We can create another dictionary out of the received
cookies and can pass this dictionary into our render function to be
passed to our html file. Yay!&lt;/p&gt;
&lt;p&gt;Thanks Margo for working on this project with me, its been an adventure!&lt;/p&gt;</summary><category term="Web"></category></entry><entry><title>Lisp Interpreter: Episode 3 (The Finally!) ... Continued.</title><link href="http://lmontopo.github.io/lisp-interpreter-episode-3-the-finally-continued.html" rel="alternate"></link><updated>2014-11-24T05:00:00-05:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-11-24:lisp-interpreter-episode-3-the-finally-continued.html</id><summary type="html">&lt;p&gt;In last week's episode we inspected how my program tokenizes and parses
the user's input. In the spirit of finishing this series of blog posts,
I have decided today to present an overview of how the rest of my
program works. We'll walk through the basic algorithm that my program
follows, pausing at some of the more exciting and important parts. I'll
do my best to skip over the less exciting bits of code, while still
providing enough information to convey the general ideas. If anyone
would like to see the code in its entirety, feel free to check it out on
my github account: &lt;a href="https://github.com/lmontopo/Lispeter"&gt;https://github.com/lmontopo/Lispeter&lt;/a&gt;. As always, I
welcome any questions or comments about either this blog post or the
code i'm describing. Lets begin!&lt;/p&gt;
&lt;p&gt;After the user's Scheme input is parsed and tokenzied, it is passed to a
function which 'unwraps' it. This funciton is called 'outer_evaluate'.
Remember how, in the tokenzier, the input gets wrapped in an extra set
of parenthesis? My 'outer_evaluate' function is how I dealt with this.
It evaluates from left to right each of the internal expressions within
the parsed expression and then it spit out the result of the last
expression. Here's the function:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;outter_evaluate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;list_input&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;evaluated_list&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;expression&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;list_input&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;evaluated_list&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;expression&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;evaluated_list&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Here, 'evaluate' is the main function that interprets the parsed input.
Inside 'evaluate' the input is classified as either a list or an atom
and is passed to the 'is_cons' and 'is_atom' functions respectively.
The 'is_atom' function is pretty straightforward since atoms are
self-evaluating, but I'll take a bit of time to describe how the
'is_cons' function works.&lt;/p&gt;
&lt;p&gt;When 'is_cons' is called it inspects the first element of the list that
is inputed. Assuming that our input is a valid Scheme expression, we
expect the first item in this list to be a function. 'is_cons' will
check to see if this function is in our pre-defined list of special
functions. (Recall that special functions are the ones that change the
flow of the interpretation.) Once the program has decided if the
function is special or not, input is directed to either the
'is_special' or 'is_regular' function, whichever is appropriate. Lets
talk a bit about both of these functions.&lt;/p&gt;
&lt;p&gt;The 'is_special' function consists of a case by case evaluation of what
to do for each special operator. I'll just present a subset of this
function because the whole thing is a little long and overwhelming.
Here's some of it:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;call_special&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;list_input&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;head&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;rest&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;list_input&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="n"&gt;list_input&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:]&lt;/span&gt;

    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;map&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="n"&gt;new_head&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;list_to_act_on&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="n"&gt;evaluate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="n"&gt;new_list&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;
            &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;item&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;list_to_act_on&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                &lt;span class="n"&gt;new_item&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;interpret&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;(&lt;/span&gt;&lt;span class="si"&gt;%s&lt;/span&gt;&lt;span class="s"&gt; &lt;/span&gt;&lt;span class="si"&gt;%s&lt;/span&gt;&lt;span class="s"&gt;)&amp;quot;&lt;/span&gt; &lt;span class="o"&gt;%&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;new_head&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;item&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
                &lt;span class="n"&gt;new_list&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;new_item&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;new_list&lt;/span&gt;


    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;define&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="nb"&gt;type&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt; &lt;span class="ow"&gt;is&lt;/span&gt; &lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;add_values&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
            &lt;span class="k"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                &lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;][&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
                &lt;span class="n"&gt;expression&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;MakeLambda&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;][&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:],&lt;/span&gt; &lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:])&lt;/span&gt;
                &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;add_values&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;expression&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="n"&gt;too_many&lt;/span&gt;

    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;lambda&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;func&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;MakeLambda&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:])&lt;/span&gt;
        &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;add_values&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;lam&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;func&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;lam&amp;#39;&lt;/span&gt;


    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;quote&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;list_input&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
        &lt;span class="k"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="n"&gt;quote_error&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;The input is split into the 'head' and 'rest', the 'head' being the
special operator. Each special function has a corresponding bit of code
which indicates how to interpret that kind of expression. Notice that
when we encounter 'lambda' and 'define' operators we use some sort of
'MakeLambda' magic. Don't worry, i'll come back to explaining this
magic, but first I want to present the 'call_regular' function, where
more magic appears!&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6
7
8
9&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;call_regular&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;list_input&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;new_list_input&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[]&lt;/span&gt;

    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;term&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;list_input&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;new_list_input&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;term&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;

    &lt;span class="n"&gt;list_input&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;new_list_input&lt;/span&gt;
    &lt;span class="n"&gt;head&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;rest&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;list_input&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="n"&gt;list_input&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:]&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;fetch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;head&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;do_fun&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;In contrast to the 'call_special' function which outlines a specific
proceedure for each special operator, the regular functions are all
dealt with in exactly the same way. This is something I'm quite proud
of. Its just so &lt;em&gt;pretty&lt;/em&gt;!&lt;/p&gt;
&lt;p&gt;Again, notice the magic... I'm calling some 'do_fun' method on some
'env.fetch' thing... What is all this?! To explain whats going on here,
I'll start by talking about environments. I implimented a class called
Scope to keep track of my environment throughout the evaluation process.
Here it is:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="c"&gt;# --- DEFINING SCOPE --- &lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Scope&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;parent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="bp"&gt;None&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;env&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;parent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;parent&lt;/span&gt;

    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;add_values&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt;

    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;fetch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;keys&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
        &lt;span class="k"&gt;elif&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;parent&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="bp"&gt;None&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;parent&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;fetch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Every scope object consists of an environment and a parent. The
environment is a dictionary containing variables/functions and their
values/expressions. The parent of a scope instance is the smallest scope
containing it. If a scope's parent is not specified then it gets the
default parent, 'None'. The global scope will have a None parent but all
other scopes should have a legitimate parent, possibly the global scope.&lt;/p&gt;
&lt;p&gt;Lets inspect the methods of the Scope class. The 'add_values' method
simply updates the environment by adding more key value pairs. The
'fetch' method looks up variables in the scope's environment. Notice
that if we have no luck looking up a variable in the current
environment, then fetch will redirect us to our parent's environment.
This means that even if our current scope is not the global scope, all
of the variables in the global environment can still be accessed. But,
since we look in our current scope first, it also means that we can
re-define any of the global variables in our current scope, and, when we
fetch for the values of these variables, we'll get the appropriate,
re-defined, value.&lt;/p&gt;
&lt;p&gt;By now we should understand that &lt;code&gt;env.fetch(head)&lt;/code&gt; is returning the
value of the key 'head' from the dictionary in our current scope. What
we have yet to discuss is what 'MakeLambda', and 'do_fun' are refering
to. Here's the bit of code that defines these terms:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="c"&gt;# ------ CLASSES OF FUNCTIONS ------&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;MakeLambda&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;first&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;second&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;first&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;first&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;second&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;second&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;params&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;first&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;exp&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;second&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;do_fun&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;zipped&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;zip&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;params&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;temp_scope&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;Scope&lt;/span&gt;&lt;span class="p"&gt;({},&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;param&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;arg&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;zipped&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="n"&gt;temp_scope&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;add_values&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;param&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;arg&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;evaluate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;exp&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;temp_scope&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;


&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;MakePyFun&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;everything&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt; &lt;span class="n"&gt;everything&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;everything&lt;/span&gt;

    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;do_fun&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;arguments&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;arguments&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;everything&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;arguments&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;elif&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;arguments&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;everything&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;arguments&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;These classes are used to create function objects. I use the MakePyFun
class to make function objects out of the built-in, non-special, Scheme
functions. I use MakeLambda to make function objects for user defined
functions. (You'll remember that this MakeLambda was called when the
user input contained either 'lambda' or 'define' expressions.) The main
difference between these two classes is that functions created with the
MakeLambda class have a defined set of parameters which are specified in
their definition. This means that instances of MakeLambda cannot operate
on an arbitrary number of arguments. In comparison, functions defined
using the MakePyFun class, &lt;em&gt;can&lt;/em&gt; be called on an aribitrary number of
arguments. One very important thing to notice, though, is that both the
MakePyFun class and the MakeLambda class have 'do_fun' methods which do
essentially the same thing: They take in some arguments and evaluate the
function on those arguments. This is how the 'call_regular' function
needed only to fetch the value of 'head' in our current scope and call
'do_fun' on the result. It didn't matter whether the result of fetch
was an instance of MakeLambda or of MakePyFun, because both have the
'do_fun' method!&lt;/p&gt;
&lt;p&gt;At this point I've pretty much described all of the exciting aspects of
my program. But, before wrapping up this blog series, I think I owe it
to anyone who's made it this far to present a nice solid example.&lt;/p&gt;
&lt;p&gt;Consider the user input &lt;code&gt;((define (f x)(+ x x))(f 4))&lt;/code&gt;. After this
expression is tokenized and parsed it will enter the 'outer_evaluate'
function as: &lt;code&gt;[['define', ['f', 'x'], ['+', 'x', 'x']], ['f', '4']]&lt;/code&gt;.
'Outter_evaluate' then calls 'evaluate' on the first item in this list,
&lt;code&gt;['define', ['f', 'x'], ['+', 'x', 'x']]&lt;/code&gt;. Evaluate decides that this is
a list, and passes it on to the 'is_cons' function. 'is_cons' decides
that 'define' is a special function and passes the expression to
'call_special'. In 'call_special', 'head' is assigned to 'define' and
'rest' to &lt;code&gt;[['f', 'x'], ['+', 'x', 'x']]&lt;/code&gt;. Since the
&lt;code&gt;if 'head' == 'define'&lt;/code&gt; condition is satisfied, it's consequent block of
code is executed. This assigns 'name' to 'f' and 'expression' to
&lt;code&gt;MakeLambda(['x'], ['+', 'x', 'x'])&lt;/code&gt; and adds them as a key-value pair
to our current environment. The first part of the user input has now
been evaluated, and control is turned back over to the &lt;code&gt;outter_evaluate&lt;/code&gt;
function which calls &lt;code&gt;evaluate(['f', '4'])&lt;/code&gt;. From 'evaluate' we are
redirected to 'is_cons' and then to 'call_regular'. In 'call_regular'
the value of 'f' is fetched from our current environment, returning the
MakeLambda object we previously instantiated. It's 'do_fun' method is
called with argument '4', returning &lt;code&gt;evaluate(['+', 'x', 'x'], env)&lt;/code&gt;
where env contains &lt;code&gt;{'x' : '4'}&lt;/code&gt;. This time 'evaluate' directs us once
again 'is_cons' which directs us to 'is_regular'. Here, both x's
evaluate to 4. and then we fetch '+' from our environment. We will not
find '+' in our current environment, but will find it in the global
environment. &lt;code&gt;env.fetch('+')&lt;/code&gt; will return the instance of 'MakePyFun'
associated to addition. This will be called on the arguments
&lt;code&gt;['4','4']&lt;/code&gt;, and finally, 8 will be returned. Phew.&lt;/p&gt;
&lt;p&gt;And finally, I have finished my series of interpreting the interpreter.
I've learned alot through this project, and had a lot of fun in the
process. Thanks again to the awesome &lt;a href="http://akaptur.com"&gt;Allison
Kaptur&lt;/a&gt; for suggesting this project to me and for
your encouragement along the way. To anyone else out there who is
contemplating writing a lisp interpreter, I whole heartedly encourage
you to do so!&lt;/p&gt;
&lt;p&gt;Thanks for reading!&lt;/p&gt;</summary></entry><entry><title>Little Lessons 3: URI's, 'urllib', Template engines, and generators.</title><link href="http://lmontopo.github.io/little-lessons-3-uris-urllib-template-engines-and-generators.html" rel="alternate"></link><updated>2014-11-19T05:00:00-05:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-11-19:little-lessons-3-uris-urllib-template-engines-and-generators.html</id><summary type="html">&lt;p&gt;I've learned so many fun little lessons over the past week, its time for
another post!&lt;/p&gt;
&lt;h4&gt;What is a URI? Is it the same as a URL?&lt;/h4&gt;
&lt;p&gt;URI stands for uniform resource identifier. A very common form of a URI
is the URL, which stands for uniform resource locator. The URL is just
the address of a website - ie. the thing you type into your browser when
you want to visit a webpage. Apparently, sometimes, the terms URI and
URL are used interchangeably. But, if you want to be precise, know that
a URL is a type of URI. Time to dig a little deaper into URL's...&lt;/p&gt;
&lt;h4&gt;What meant by the 'path' and the 'query' of a URL?&lt;/h4&gt;
&lt;p&gt;The wikipedia page,
&lt;a href="http://en.wikipedia.org/wiki/Uniform_resource_locator"&gt;here&lt;/a&gt;, does a
good job at explaining the URL. I'll summarize what I learned from it
here. The URL consists of several different parts. I'll introduce these
parts and discuss them with respect to this example:
http://www.cineplex.com/Search?Query=Interstellar&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;The very first part of the URL is the &lt;strong&gt;protocol&lt;/strong&gt;. It specifies
    which application protocol is being used to obtain the resource. In
    our example the application protocol is 'http'.&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;domain name&lt;/strong&gt; can be an IP address or a registered and easier
    to remember name associated to an IP address. In our example the
    domain name is 'cineplex.com'. If you are creating a server on your
    own computer, your domain name might be 'localhost'.&lt;/li&gt;
&lt;li&gt;After the domain name a &lt;strong&gt;port number&lt;/strong&gt; can optionally be specified.
    By default we are directed to port 8000, and so it is almost always
    unnecessary to manually specify a port.&lt;/li&gt;
&lt;li&gt;A single domain name or IP address can host a multitude of files.
    The particular file/resource that a URL is after is specified by the
    &lt;strong&gt;URL path&lt;/strong&gt;. It specifies the address of the particular file we are
    requesting and is analogous to the way in which we specify the path
    to a particular file within our own computer. In our example the URL
    path is '/Search'.&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;query string&lt;/strong&gt; contains data (usually inputed by the user)
    which will be passed to some sort of software running on the server.
    The example I've shown is the result of typing "Interstellar" into
    the search bar on the cineplex homepage. "Interstellar" was passed
    to the servers computer and used in some program to figure out the
    output. Then the results were passed back to me in the webpage with
    URL "http://www.cineplex.com/Search?Query=Interstellar". The query
    string part of the URL is '?Query=Interstellar'. As far as I know,
    the query string always starts with a question mark.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;urllib.uncode('string') is great! Here's why:&lt;/h4&gt;
&lt;p&gt;As I may have previously mentioned, I have decided to write my own web
framework. Not because I think I can do a better job than the existing
frameworks, but because I want to learn more about what is happening
behind the scenes with web development. An issue I encountered as I
developped my framework involved html forms and processing user input.
If a user inputed any special characters, like '!', '\~', '?', etc., my
browser would encode these characters and send my server an http request
with these encodings. For example, '!' was encoded as '%21'. Why is the
browser doing this? Although its tempting to think that this character
encoding is just a pain in the butt, its actually pretty useful! Indeed,
some characters in the URL have a special meaning. The question mark,
for example, is always used to signify the begining of a query. So
whenever the &lt;em&gt;USER&lt;/em&gt; inputs characters which have (or may have) a special
meaning, the browser will encode these characters to avoid confusion.
The places where these characters are used by the browser to indicate a
special meaning, they are NOT encoded. So, to make this clear, when a
user inputs "?" into a form, it will be encoded. But if a query string
is present, the "?" at the begining of the query will not be encoded.
And this makes my life alot easier when I have to parse through the raw
http requests. I can guarantee that whenever I see a "?" it is
signifying the begining of a query string, and NOT some user input.
Great! But now, I DO have to worry about decoding the encoded characters
so that they can correctly be passed as a variable to an html page. How
do I decode a special character from its encoded represenation? Using
the python's urllib module!! Check it out:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6
7
8
9&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;urllib&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;quote&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;!!!&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="s"&gt;&amp;#39;&lt;/span&gt;&lt;span class="si"&gt;%21%&lt;/span&gt;&lt;span class="s"&gt;21%21&amp;#39;&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;encoded_input&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;urllib&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;quote&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;amp;!?&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="n"&gt;encoded_input&lt;/span&gt;
&lt;span class="o"&gt;%&lt;/span&gt;&lt;span class="mi"&gt;26&lt;/span&gt;&lt;span class="o"&gt;%&lt;/span&gt;&lt;span class="mi"&gt;21&lt;/span&gt;&lt;span class="o"&gt;%&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="n"&gt;F&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;decoded_input&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;urllib&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;unquote&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
&lt;span class="n"&gt;encoded_input&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="n"&gt;decoded_input&lt;/span&gt;
&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="err"&gt;!?&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;h4&gt;What is a template engine?&lt;/h4&gt;
&lt;p&gt;A template engine provides a way for users to put variables and possibly
even logic into their html templates. Templating engines consist of a
templating language and a templating compiler. The templating language
specifies syntax that will be understood to mean specific things in your
html template. So, for example, you could say that two curly braces will
enclose any variables and that a curly brace and a percent sign will
enclose any python logic. Then, you're compiler will parse this html
template and then will see which parts need to perform logic or input
variables, and will ultimately translate the template into an html page
void of any logic or variables, that can be displayed by your browser.
Often, template engines are part of what makes up a web framework.&lt;/p&gt;
&lt;h4&gt;Generators are a kind of python object!&lt;/h4&gt;
&lt;p&gt;You know how you can write lists like:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;abcdefg&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;a&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;b&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;c&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;d&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;e&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;f&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;g&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;This way of specifying a list is called a &lt;strong&gt;list comprehension&lt;/strong&gt;. I just
found out yesterday that if we write the same thing but instead use the
non-square embraces, then we create something called a generator. Check
it out:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;abcdefg&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;generator&lt;/span&gt; &lt;span class="nb"&gt;object&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;genexpr&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;at&lt;/span&gt; &lt;span class="mh"&gt;0x10b323910&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Woah! So whats a generator? I honestly don't know. Yet. All I know is
that its a different kind of python object, one which I had previously
no idea about. By typing in `dir((x for x in 'abcdef')) we can see the
collection of methods that generators have, and it is, obviously, a
different collection than the methods associated with lists. I hope to
come back to generators in the future to explain why they are used and
what they are good for!&lt;/p&gt;
&lt;h4&gt;Hexadecimal Numbers in Python&lt;/h4&gt;
&lt;p&gt;Have you ever seen numbers starting with 0x in python, and not really
known what they were for? I have seen these around, and always just
thought they were some sort of complicated encoding. In reality, numbers
begining with 0x are just hexidecimal numbers - ie. numbers with base 16
instead of 10. (If you aren't familiar with hexidecimal numbers, no
worries. You can read up on it
&lt;a href="http://simple.wikipedia.org/wiki/Hexadecimal_numeral_system"&gt;here&lt;/a&gt;.) So
we can write:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="mh"&gt;0x11&lt;/span&gt;
&lt;span class="mi"&gt;17&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;since 11 is the base 16 representation of the decimal number 17. Mystery
solved.&lt;/p&gt;</summary><category term="Web"></category></entry><entry><title>Lisp Interpreter: Episode 3 (The Finally!)</title><link href="http://lmontopo.github.io/lisp-interpreter-episode-3-the-finally.html" rel="alternate"></link><updated>2014-11-18T05:00:00-05:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-11-18:lisp-interpreter-episode-3-the-finally.html</id><summary type="html">&lt;p&gt;Let me start off by apologizing for the delay. I've been hesitant to
write this post for several reasons, including:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Presenting and explaining my entire lisp interpreter is a BIG (and
    therefore daunting) task.&lt;/li&gt;
&lt;li&gt;There are parts of my code that I'm not entirely satisfied with and
    I &lt;em&gt;may&lt;/em&gt; refactor these parts in the future. For this reason, I've
    been debating waiting until I finish refacturing to write this post.&lt;/li&gt;
&lt;li&gt;The parts of my code that I'm unsatisfied with are pretty ugly and
    are a pain to read. Which leads me to the next point...&lt;/li&gt;
&lt;li&gt;Will anyone actually read this?&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;I have decided to go ahead and write this blog post anyway. Even if no
one reads it, I think that I'll benefit from writing it. As far as the
ugly bits go, I'm trying to not let 'perfect' be the enemy of 'good
enough'. This project is far from perfect but that OK. I worked hard on
it, it works, I learned lots during the process, and those are the
things that matter most. Besides, I've gotten really excited this week
about some other projects, so it could be a while before I get back to
refacturing the interpreter.&lt;/p&gt;
&lt;p&gt;OK. Lets get started. Here are the first ten lines of code:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6
7
8
9&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="nn"&gt;__future__&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;division&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="nn"&gt;termcolor&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;colored&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="nn"&gt;sys&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="nb"&gt;exit&lt;/span&gt;

&lt;span class="c"&gt;# ------ GlOBAL LISTS ------&lt;/span&gt;
&lt;span class="n"&gt;symbol&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;+&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;-&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;*&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;/&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;lt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;lt;=&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;=&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;gt;=&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;abs&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;list&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;if&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;not&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="s"&gt;&amp;#39;set!&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;begin&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;let&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;define&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;lambda&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;quote&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="n"&gt;special&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;set!&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;begin&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;let&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;define&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;lambda&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;cond&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;quote&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;if&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;     
            &lt;span class="s"&gt;&amp;#39;list&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;map&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;cons&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;car&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;cdr&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;The first 3 lines just specify any functions I'll be using from built in
libraries. Next, two important global lists are introduced. The list,
'symbol', specifies strings that have a special meaning and will
therefore be treated differently from other strings of characters. The
list 'special' is a list of all of the built in Scheme functions which
disrupt the flow of the interpretation. All functions, including
addition, subtraction, etc. will be treated in the same way. But our
interpreter will treat these 'special' functions differently.&lt;/p&gt;
&lt;p&gt;Next, we introduce my class of exceptions and some instances of that
class:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="c"&gt;# ------ EXCEPTIONS ------&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;MyError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ne"&gt;Exception&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;msg&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;msg&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;msg&lt;/span&gt;

&lt;span class="n"&gt;if_error&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;MyError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;Error: you need to specify by a consequence and an alternate.&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;dict_error&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;MyError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;Error: can&amp;#39;t find element in dictionary. Improper input.&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;first_error&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;MyError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Error: unexpectedly entered parse function with no input.&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;too_many&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;MyError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;Error: too many arguments were inputed.&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;quote_error&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;MyError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Error: quote only takes one operand.&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;let_error&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;MyError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Error: let must be followed by a list.&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Then, we start doing some of the gritty work: tokenizing and parsing. I
have implemented both my tokenizer and my parser as functions. When we
call them, the output of the tokenizer will be fed as input to my
parser. Here is my tokenizer:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="c"&gt;# ------ TOKENIZE ------- &lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;tokenizer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;holder&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;holder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;(&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;holder&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;)&amp;#39;&lt;/span&gt;
    &lt;span class="n"&gt;holder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;holder&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;replace&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;(&amp;#39;&lt;/span&gt; &lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39; ( &amp;#39;&lt;/span&gt; &lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;holder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;holder&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;replace&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;)&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39; ) &amp;#39;&lt;/span&gt; &lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;final&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;filter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;lambda&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;holder&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39; &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;final&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;The tokenizer takes my user's raw input - something like &lt;code&gt;(+ 2 2)&lt;/code&gt;. It
begins by putting extra braces around the entire thing. It then adds
space around all the braces before splitting the input into an array
where each element is a separate token. The input splits over spaces,
which is why it was necessary to add extra space around the braces. far
so good, but why did I begin by adding extra braces?! Seems kind of
wierd, right?&lt;/p&gt;
&lt;p&gt;The reason for this seemingly cooky choice was to accomodate inputs like
the following: &lt;code&gt;(define x 3) x&lt;/code&gt;. This is a valid Scheme expression which
evaluates to 3. Suppose that I do not add extra brackets around the
entire statement. Then, when I go to actually &lt;em&gt;interpret&lt;/em&gt; the input, it
becomes difficult to know when the end of the user input has been
reached. In fact, I did NOT initially add these extra brackets in my
tokenization, but my interpreter evaluated &lt;code&gt;(define x 3) x&lt;/code&gt; to be &lt;code&gt;None&lt;/code&gt;
instead of &lt;code&gt;3&lt;/code&gt;. It simply stopped evaluating after &lt;code&gt;(define x 3)&lt;/code&gt;.
Knowing when the end of the user input has been reached, however, is
quite easy if we have an outter set of brackets enclosing everything. Of
course, adding extra brackets came with its own set of issues. I needed
to make sure that my interpreter could differentiate between expressions
like &lt;code&gt;(3)&lt;/code&gt; and &lt;code&gt;3&lt;/code&gt;. Although '3' is a valid Scheme expression, &lt;code&gt;(3)&lt;/code&gt; is
not, and I was essentially changing my input to always look like &lt;code&gt;(3)&lt;/code&gt;.
Thanks to Mary Cook, I came up with a pretty clever solution to this
issue, which we will come accross later.&lt;/p&gt;
&lt;p&gt;Continuing on... the parser! Writing this parser was my first encouter
with recursion! Here's the code:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="c"&gt;# ---- PARSER ----- &lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;parse&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tokens&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tokens&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="n"&gt;first_error&lt;/span&gt;

    &lt;span class="n"&gt;token&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;tokens&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="n"&gt;tokens&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;tokens&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:]&lt;/span&gt;

    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;token&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;(&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;parsed_input&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt; 

        &lt;span class="k"&gt;while&lt;/span&gt; &lt;span class="n"&gt;tokens&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;)&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="n"&gt;to_append&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;tokens&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;parse&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tokens&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="n"&gt;parsed_input&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;to_append&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;tokens&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;tokens&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:]&lt;/span&gt;                 &lt;span class="c"&gt;# pops off the &amp;#39;)&amp;#39; part&lt;/span&gt;

        &lt;span class="c"&gt;#we add a condition to check if last return&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tokens&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;parsed_input&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;tokens&lt;/span&gt;     &lt;span class="c"&gt;# if not last return, return current version of holder&lt;/span&gt;
        &lt;span class="k"&gt;elif&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tokens&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;parsed_input&lt;/span&gt;             &lt;span class="c"&gt;# if last return, only return new_holder            &lt;/span&gt;
    &lt;span class="k"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;check_type&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;token&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;tokens&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;To better understand this function, lets look at how
&lt;code&gt;parse(['(', '(', +, '1', '1', ')', ')'])&lt;/code&gt; would be processed, line by
line. Line 3 is not satisfied, so we skip to line 6 and 7. Here Token
will be set to &lt;code&gt;'('&lt;/code&gt;, tokens will become
&lt;code&gt;[ '(', '+', '1', '1', ')', ')']&lt;/code&gt;. Since the condition on line 9 is
satisfied, we then enter this branch and continue on with line 10 where
&lt;code&gt;parsed_input&lt;/code&gt; is initialized as an empty list. Then we enter the while
loop on line 12, and in line 13 we recurse back into our parse function
by calling &lt;code&gt;parse(tokens)&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Now in the second level of our parse function. In this level we execute
line 6 and 7 again, setting &lt;code&gt;token&lt;/code&gt; as &lt;code&gt;'('&lt;/code&gt;, and &lt;code&gt;tokens&lt;/code&gt; to
&lt;code&gt;['+', '1', '1',')', ')']&lt;/code&gt;. Since &lt;code&gt;token&lt;/code&gt; is still &lt;code&gt;'('&lt;/code&gt;, line 10 will
again be executed, creating another &lt;code&gt;parsed_input&lt;/code&gt; list, and then diving
into our 3rd level of recursion on &lt;code&gt;parse&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;In this 3rd level, token is &lt;code&gt;'+'&lt;/code&gt; and tokens is &lt;code&gt;['1', '1', ')', ')']&lt;/code&gt;.
Since token is not &lt;code&gt;'('&lt;/code&gt; we skip down to the else condition and execute
line 23. Since we have yet to define the function check_type, just
pretend that this line returns token and tokens. Having returned those
values, we come out of the 3rd layer of recursion and back into the 2nd,
at line 13. Here, &lt;code&gt;to_append&lt;/code&gt; is set to '+', and tokens is
&lt;code&gt;['1', '1', ')', ')']&lt;/code&gt;. Line 14 is then executed, and &lt;code&gt;parsed_input&lt;/code&gt;
becomes &lt;code&gt;['+']&lt;/code&gt;. We continue looping through this while loop, going into
a 3rd layer of recursion, coming back into two, and appending
&lt;code&gt;parsed_input&lt;/code&gt; until &lt;code&gt;parsed_input&lt;/code&gt; looks like ['+', '1', '1'] in our
second layer of recursion. At this point the tokens[0] will be ')', so
we break out of the while loop. Line 15 remouves ')' from tokens,
leaving tokens as [')']. Then since the length of tokens is positive
line 19 is executed.&lt;/p&gt;
&lt;p&gt;Now we exit the second layer of recursion and are back into the first
parse call. &lt;code&gt;to_append&lt;/code&gt; becomes &lt;code&gt;['+', '1', '1']&lt;/code&gt;, and &lt;code&gt;tokens&lt;/code&gt; is
&lt;code&gt;[')']&lt;/code&gt;. The original &lt;code&gt;parsed_input&lt;/code&gt; is updated to &lt;code&gt;[['+', '1', '1']]&lt;/code&gt;,
the while loop ends, and line 15 is executed, changing &lt;code&gt;tokens&lt;/code&gt; to &lt;code&gt;[]&lt;/code&gt;.
Since the &lt;code&gt;len(tokens)&lt;/code&gt; is zero line 20 is executed and &lt;code&gt;parsed_input&lt;/code&gt;
is the final return. We have exited all levels of the parse function,
effectively parsing the input!&lt;/p&gt;
&lt;p&gt;This blog post will be continued... I have written enough for one day.&lt;/p&gt;</summary></entry><entry><title>Adventures with sockets, threads and more!</title><link href="http://lmontopo.github.io/adventures-with-sockets-threads-and-more.html" rel="alternate"></link><updated>2014-11-11T00:00:00-05:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-11-11:adventures-with-sockets-threads-and-more.html</id><summary type="html">&lt;p&gt;For a while now I've wanted to learn more about the internet, about
servers, and about how web apps &lt;em&gt;really&lt;/em&gt; work. Last week I finished a
small flaks tutorial. I enjoyed the tutorial and I learned some cool
things by doing it, yet, I was feeling unsatisfied. The tutorial just
didn't hit the spot for me. I wasn't really sure what I was after, but I
knew it was something deeper. Yesterday I discovered sockets, and it was
dead on!&lt;/p&gt;
&lt;p&gt;This blog post is going to be a (not so) little write up of some things
I've learned as I digging around in the world of sockets and other
networky type things. I'll start with a few questions I was thinking
about yesterday. I'll provide what I think are some decent and mostly
true answers to these questions. (Of course, if you find something in
this post that is just outright wrong, please do reach out to correct
me!). Then I'll introduce some code Susan and I wrote to make a simple
web chat service using sockets. Finally, a second round of questions and
answers will be presented. Enjoy!&lt;/p&gt;
&lt;h4&gt;QUESTIONS ROUND 1&lt;/h4&gt;
&lt;h5&gt;What's a socket?&lt;/h5&gt;
&lt;p&gt;This is a question I've spent a great deal of time trying to answer.
Here's the answer I've settled on: A socket is some sort of abstract
object like that of a "file" on your computer. We could say that the
object type "socket" is built into the operating system of our computer
and allows users (or programs) to create instances of them at will.
Sockets are used as the endpoints of any bidirectional communication
channel. The socket contains the FROM IP address, the TO IP address, the
FROM port number, and the TO port
number.&lt;sup id="fnref:1"&gt;&lt;a class="footnote-ref" href="#fn:1" rel="footnote"&gt;1&lt;/a&gt;&lt;/sup&gt; We can think about the function of sockets to be like plugging chords
into walls on the two ends of your communcation channel.&lt;/p&gt;
&lt;h5&gt;How does my computer communicate with my router?&lt;/h5&gt;
&lt;p&gt;The short answer: via radio signals. Modern computers come with a built
in wireless adapter which translates data from your computer into radio
waves. These radio waves can then be sent out into the world and picked
up by a router. Communication can occur in the other direction as well:
The router can send radio waves to a comptuer and the computer will
translate those waves into 0s and 1s so that it can understand the
message. One thing that I found interesting is that my computer is
always listening to the router. Sometimes my computer will hear messages
that aren't even addressed to it, in which case it won't accept these
messages. So there's a difference between "listening" and "accepting"
messages from the router. We'll come back to this!&lt;/p&gt;
&lt;h5&gt;Can older computers connect to the internet?&lt;/h5&gt;
&lt;p&gt;It depends. If your computer has the necessary internet handling
software but is simply lacking a translater, then yes. The modem,
afterall, is simply a translator. It takes signals (probably passed to
it through your phone line) and transforms these messages into 0s and 1s
that your computer can understand. But, this only makes your computer
internet ready if you're operating system can create sockets, and can
understand and work with internet protocols. Otherwise, extra software
would have to be implimented and I'm not exactly sure if this can always
be done.&lt;/p&gt;
&lt;h5&gt;SOME CODE&lt;/h5&gt;
&lt;p&gt;To learn more about sockets Susan and I implimented a chat service
between our two computers using sockets. I wrote the code for the
"server", and she wrote the code for the "client". If I ran 'server' on
my computer and then she ran 'client' on hers, we were able to chat back
and forth in our terminals! Anything I wrote in my terminal would be
sent to hers the moment I pressed enter. Likewise, messages she typed in
her terminal would be sent to mine when she pressed enter. It was like a
real world chat service! Here's our code:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="c"&gt;###SERVER (On Leta&amp;#39;s Computer)&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="nn"&gt;socket&lt;/span&gt; 
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="nn"&gt;threading&lt;/span&gt;

&lt;span class="n"&gt;serversocket&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;socket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;socket&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;

&lt;span class="c"&gt;#host = socket.gethostname()&lt;/span&gt;

&lt;span class="n"&gt;port&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;9999&lt;/span&gt;

&lt;span class="n"&gt;serversocket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;setsockopt&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;socket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;SOL_SOCKET&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;socket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;SO_REUSEADDR&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;serversocket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;bind&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;10.0.7.65&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;

&lt;span class="c"&gt;# queue up to 5 requests:&lt;/span&gt;
&lt;span class="n"&gt;serversocket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;listen&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;clientsocket&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;addr&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;serversocket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;accept&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;listen&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;connection&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;while&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;msg&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;clientsocket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;recv&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1000&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;msg&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;break&lt;/span&gt;
        &lt;span class="k"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;friend says&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;msg&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;write&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;connection&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;while&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;message&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;raw_input&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;clientsocket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;HTTP/1.0 200 OK&lt;/span&gt;&lt;span class="se"&gt;\n\n&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;clientsocket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;sendall&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;message&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;clientsocket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;close&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;

&lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;threading&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Thread&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;target&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;write&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;clientsocket&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;span class="n"&gt;r&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;threading&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Thread&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;target&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;listen&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;clientsocket&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;

&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;start&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;start&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="c"&gt;#CLIENT (on Susan&amp;#39;s computer)import socket&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="nn"&gt;sys&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="nn"&gt;threading&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;server&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="n"&gt;sock&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;socket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;socket&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;socket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;AF_INET&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;socket&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;SOCK_STREAM&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="n"&gt;HOST&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;
    &lt;span class="n"&gt;SOCKET_LIST&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;
    &lt;span class="n"&gt;RECV_BUFFER&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;4096&lt;/span&gt;
    &lt;span class="n"&gt;PORT&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;9999&lt;/span&gt;

    &lt;span class="n"&gt;server_addr&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;10.0.7.65&amp;quot;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;PORT&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&amp;gt;&lt;/span&gt;&lt;span class="n"&gt;sys&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;stderr&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;connecting to &lt;/span&gt;&lt;span class="si"&gt;%s&lt;/span&gt;&lt;span class="s"&gt; port &lt;/span&gt;&lt;span class="si"&gt;%s&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;%&lt;/span&gt; &lt;span class="n"&gt;server_addr&lt;/span&gt;
    &lt;span class="n"&gt;sock&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;connect&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;server_addr&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;try&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;threading&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Thread&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;target&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;sock&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
        &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;start&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
        &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;hi!!!! TESTING!!&amp;quot;&lt;/span&gt;
        &lt;span class="k"&gt;while&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="n"&gt;data&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;sock&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;recv&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;RECV_BUFFER&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&amp;gt;&lt;/span&gt;&lt;span class="n"&gt;sys&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;stderr&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;Leta says: &lt;/span&gt;&lt;span class="si"&gt;%s&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;%&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;

    &lt;span class="k"&gt;finally&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&amp;gt;&lt;/span&gt;&lt;span class="n"&gt;sys&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;stderr&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;closing socket&amp;#39;&lt;/span&gt;
        &lt;span class="n"&gt;sock&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;close&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;h4&gt;QUESTIONS ROUND 2&lt;/h4&gt;
&lt;h5&gt;What is happening when I write "socket.listen"?&lt;/h5&gt;
&lt;p&gt;As mentioned earlier, your computer is constantly "listening" to
messages from your router. But its not necessarily ACCEPTING them.
Calling socket.listen() tells your computer to actively start accepting
messages that are addressed to the socket. So, as soon as my computer
sees some message addressed to a socket which has been told to listen,
the socket will send back a message saying something like, "OK, I am
willing to receive your message". And then the message will be sent and
received. (At least I think thats kind of how it goes.)&lt;/p&gt;
&lt;h5&gt;What is TCP? What is IP? Are they related?&lt;/h5&gt;
&lt;p&gt;TCP stands for Transmission Control Protocoll. IP stands for Internet
Protocol. Both are "protcols" in the sense that they outline the
standards by which machines are supposed to communicate with each other.
To see how they differ, lets walk through how Susan's and my computer
are dealing with our 'chat server'. Suppose I send the message "hello"
to Susan. When I send this message to Susan the string "hello" will be
wrappred with extra data necessary to satisfy TCP. Once this mesage
satisfies TCP it can be sent to my operating system, which will look at
it, realize that data needs to be sent out in the world, and will
package the data with yet another layer so it adheres to IP. This
message is then translated to radio waves to be sent to the router. Upon
receiving my message the router will pass the package to Susan's
computer. When Susan's computer receives the package it translates the
data back into 0s and 1s and then begins unpacking it. Her operating
system will take off the outtermost layer of packaging: that associated
with IP. Her computer will find that the contents of this package adhere
to TCP. Susan's computer will make sure that TCP is followed. Since TCP
is a protocol which ensures that messages are sent in order, this means
that within the TCP packaging Susan's computer might find some data that
says "Hey! I'm packet number 13 sent from Leta's computer to yours. Have
you gotten package 1 through 12 already? You can't open me up until
you've received all the ones that come before." And her computer will
respond saying something like "Yes, I have gotten all the messages that
come before, so I can now open you up". Susan's computer will then pass
the package to the application (the chat service) which will unpack the
data to find the message I sent: "hello".&lt;/p&gt;
&lt;p&gt;I know this is pretty confusing. I'm still wrestling with these concepts
myself. Lets recap: On the senders side, the package gets wrapped with
all sorts of layers and then this package gets passed around, and on the
receivers side, the package gets unpacked layer by layer. Each layer is
associated with another protocol. Underneath the IP packaging, data can
be sent adhering to TCP or adhering to other protocols. Indeed, TCP is
not the only one. As I mentioned above, TCP is a protocol that ensures
that data is sent in a particular order, and it ensures that a response
be sent back to the sender to communicate if/when the data was received.
Another protocol is UDP: User Datagram Protocol. It does not ensure that
delivery has occured and does not ensure that messages are delivered in
order. We're not going to get into why UDP might be used over TCP, but
the point I wanted to make was that IP can encapsulate many different
types of messages. TCP is just the one that happened to be used in the
chat server Susan and I implimented.&lt;/p&gt;
&lt;h5&gt;What is a thread?&lt;/h5&gt;
&lt;p&gt;Have you ever heard the term "multi-threaded programming" and wondered
what the heck people were talking about? If so, read on! Consider a chat
server where I could type a message to Susan, and then I couldn't type
one again until I had her response. That would kind of suck, wouldn't
it? So what this means is that in a good chat service, my server can be
waiting for me (the user) to input a message, and can simultaneously be
listening for any incoming messages from Susan. The key here is that we
want our program to be doing &lt;strong&gt;two things simultaneously&lt;/strong&gt;. Looking at
the code for Server, above, we see that what I want is for the function
"write" and the function "listen" to be running concurrently. And the
way I implemented this was through threads. Each thread refers to a
different task that we want to be carried out, and threading is the
process of running them simultaneously. Conclusion: Threading rocks!&lt;/p&gt;
&lt;h5&gt;Are sockets being used when I use my browser to visit a webpage?&lt;/h5&gt;
&lt;p&gt;YES! Often multiple sockets are used to transfer the information of one
a single webpage to your computer. Generally speaking, each HTTP request
has its own socket that it connects with. This socket will close as soon
as the request has been made and received. Some web pages have 100s of
GET or POST (or other) HTTP requests. This means that 100s of sockets
will be created, opened, and closed on my computer in the short time it
takes to load the webpage in my browser. I have been told that this is
actually starting to change. I don't know very mucha about this, but I
think HTTP is starting to allow a single socket to handle more than one
HTTP requests.&lt;/p&gt;
&lt;div class="footnote"&gt;
&lt;hr /&gt;
&lt;ol&gt;
&lt;li id="fn:1"&gt;
&lt;p&gt;A Port is just this idea that we've implimented on our computers so
that we can have several things going on on one computer. Its kind
of like apartments on an apartment building. If we have to have
several separate things going on at different addresses within the
same machine, ports is the way we've done
that. &amp;#160;&lt;a class="footnote-backref" href="#fnref:1" rev="footnote" title="Jump back to footnote 1 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;</summary><category term="Web"></category><category term="Threading"></category></entry><entry><title>Little Lessons: Episode 2</title><link href="http://lmontopo.github.io/little-lessons-episode-2.html" rel="alternate"></link><updated>2014-11-06T05:00:00-05:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-11-06:little-lessons-episode-2.html</id><summary type="html">&lt;p&gt;Seeing as there are a whole &lt;strong&gt;bunch&lt;/strong&gt; of "little lessons" that I'd like
to write down and keep track of, I've decided to extend my previous blog
post "Little Lessons" into a whole series! Get ready!&lt;/p&gt;
&lt;h4&gt;Mutating Iterables:&lt;/h4&gt;
&lt;p&gt;Suppose we have a list and we'd like to mutate some (or all) of its
elements as we iterate through them. Supposing that the way in which we
want to mutate each element isn't too complicated, this seems like a
straight forward task.&lt;/p&gt;
&lt;p&gt;The case I was initially looking at consisted of a list where each
element of my list was either True or False. I wanted to go through the
list and change some of the False entries to True. As is the case with
many tasks in computing, this task was a little trickier than I
initially expected. For the purpose of this lesson, it will suffice to
consider a simple list of integers. Here we go!&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6
7
8&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;item&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
&lt;span class="o"&gt;...&lt;/span&gt;     &lt;span class="n"&gt;item&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;
&lt;span class="o"&gt;...&lt;/span&gt; 
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;I'm not sure about you, but this was not exactly what I was expecting
the first time I tried it. Lets add an extra print statement to better
see whats going on.&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;item&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; 
&lt;span class="o"&gt;...&lt;/span&gt;     &lt;span class="n"&gt;item&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;
&lt;span class="o"&gt;...&lt;/span&gt;     &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="n"&gt;item&lt;/span&gt; &lt;span class="mi"&gt;2345&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;It seems that our code is understanding, and executing, "item += 1",
yet, the list itself is not being mutated! HOW CAN THIS BE SO?! After a
bit of research Julia and I found our answer: when items of a list are
iterated with this 'for item in list' statement, Python creates an
element 'item' which is a copy of the value of that list element. This
item is an entirely separate object than the elements of the list, and
so changing 'item' has no effect on our list. Here's how you &lt;em&gt;can&lt;/em&gt;
change the elements in the list, as intended:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;i&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="nb"&gt;range&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;list&lt;/span&gt;&lt;span class="p"&gt;)):&lt;/span&gt;
&lt;span class="o"&gt;...&lt;/span&gt;     &lt;span class="nb"&gt;list&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;
&lt;span class="o"&gt;...&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Yay! Notice how we access the elements of the list DIRECTLY.&lt;/p&gt;
&lt;h4&gt;User-defined Exceptions/REPL/Errors vs Exceptions&lt;/h4&gt;
&lt;p&gt;Yesterday I added the finishing touches to my Lisp Interpreter. (Expect
a long and detailed post about that very soon!) My program was
interpreting Scheme as I intended it to, but it wasn't very user
friendly. I decided to turn it into a REPL. The acccronym REPL stands
for "Read, Evaluate, Print, Loop". What a REPL does is exactly what you
might think: it will read user input, evaluate it, print the result back
to the user, and then wait for further input. Using a while loop and
using Python's raw_input() command, it was pretty straightforward to
get my interpreter to work like a REPL for non-erroneous user input.
However, if the input was erroneous then the entire program crashed.
Somehow, I needed my program to ACCEPT erroneous input and respond to it
with an appropriate error message. The way I went about doing this was
by creating my own class of Exceptions! That's right: since everything
in Python is an object, Errors and Exceptions are themselves objects,
and we can create our very own classes of them!&lt;/p&gt;
&lt;p&gt;Lets step back for a minute and quickly discuss what is meant by the
terms "Error" and "Exception" in Python. I found the distinction to be a
little confusing at first. It turns out that the term "Error" is a broad
category which can be divided into two different types: Syntax Errors
and Exceptions. Syntax errors are errors which are produced because
characters or strings are misplaced, missing, or added when they
shouldn't be. In comparison, the errors which occur during execution are
refered to as "exceptions". These errors indicate that the &lt;em&gt;meaning&lt;/em&gt; (as
opposed to the syntax) of the code is erroneous.&lt;/p&gt;
&lt;p&gt;Great, now lets talk about how I implemented my own class of exceptions!
The implimentation of this class required very little code:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;MyError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ne"&gt;Exception&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;    
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;msg&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;        
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;msg&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;msg&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Then I created several different instances of this class. Each instance
refers to a different type of error that could occur, and each had a
message associated with it. Here is the function I implement in my
program which takes care of all things to do with being a REPL:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;repl&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;    
    &lt;span class="k"&gt;try&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;         
        &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;raw_input&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;gt; &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;        
            &lt;span class="k"&gt;try&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; 
                &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="n"&gt;interpret&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="k"&gt;except&lt;/span&gt; &lt;span class="n"&gt;MyError&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;   
                &lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;colored&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;msg&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;red&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;         
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;repl&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;scope&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;    
    &lt;span class="k"&gt;except&lt;/span&gt; &lt;span class="n"&gt;KeyboardIterrupt&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;        
        &lt;span class="nb"&gt;exit&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Here my code "tries" to print out the result of calling the interpret
function on the user input. If any isntance of MyError occurs, then it
will instead return the message associated to that instance of MyError.
Notice the second parameter, 'e'. It makes reference to the particular
instance of MyError which was raised and saves me from having to specify
case by case all of the instances of MyError which could be encountered.
For the record, 'e' is not some MAGIC variable that has a special
meaning in Python. It is simply what I chose to name the second
parameter. I could easily change 'e' to 'blah' and the code will work
the same. (I actually tested it out to check!)&lt;/p&gt;</summary><category term="Python"></category></entry><entry><title>Interpreting the Interpreter: Episode 2</title><link href="http://lmontopo.github.io/interpreting-the-interpreter-episode-2.html" rel="alternate"></link><updated>2014-10-30T04:00:00-04:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-10-30:interpreting-the-interpreter-episode-2.html</id><summary type="html">&lt;p&gt;&lt;strong&gt; Confession: I am not yet ready to present my final, finished, Lisp
Interpreter. It will be coming soon, but not today. Today I will
describe the rollercoaster ride of an experience taking on this project
has been for me. Then I'll focus in on a couple things I've learned
along the way. &lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Last week Sumana asked me how my interpreter was going, and I explained
to her the mixed feelings I was having about the project. I told her how
somedays I feel things are goings great - I'm learning lots, the project
is challenging, and I'm excited! But other days I feel discouraged. I'll
put a lot of energy and effort into writing a peice of code for my
project only to later realize that this peice of code will not be used
at all. Apparently, this experience is not uncommon. There is an analogy
between this experience and hill-climbing which goes something like
this: Suppose there are many hills in a region, and we would like to
reach the top of the tallest one. When we are climbing uphill we feel
like we are making great progress. We feel the effort we are putting in
is getting us very close to our goal! But then we get to the top and we
discover we've been climbing a smaller hill and that the top of the
largest hill is still far away. Furthermore, we realize that to get
there, we actually have to go back down the hill we just climbed. When
Suman described to me this analogy, I felt releived. This was EXACTLY
what I had been experiencing!! It was good to know that I wasn't alone
in feeling this way. And she reminded me that this was all part of the
learning process. Indeed, in climbing these smaller hills, I've still
learned a great deal!&lt;/p&gt;
&lt;p&gt;Here is one of the small hills I climbed, and the lessons I learned in
doing so.&lt;/p&gt;
&lt;h4&gt;All the way back to basic math.&lt;/h4&gt;
&lt;p&gt;Basic math was one of the first thing that Kuan and I tackled when we
begun writing our Lisp Interpreters. I thought I had conquered that task
long ago, but this week I realized I wrong. The code I had written to
interpret basic math looked something like this:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;+&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;-&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;*&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;/&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;lt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;gt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;lt;=&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;=&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;&amp;gt;=&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]:&lt;/span&gt;    
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;=&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;            
        &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;eval&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;==&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]))&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;    
    &lt;span class="k"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;eval&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]))&lt;/span&gt;            
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Here, head is the name given to the first element in a list. In this
case head is the operator. Notice that this code works for only two
operands. What I realized this past week is that Scheme actually accepts
math expressions with more than 2 arguments. For example, "(+ 1 1 1)" is
a legitimate scheme expression. And unfortunately, my current code
wouldn't interpret it. In the end, I changed the code to look like this:
(I'll just present a couple of functions, so that you get the idea)&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt; 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="c"&gt;# ---- Defining Basic Math and Bool Functions ----  &lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;add&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nb"&gt;sum&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;subtract&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;    
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nb"&gt;reduce&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;lambda&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;equal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;    
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:]&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;[:&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;less&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;[:&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:]&lt;/span&gt;

&lt;span class="c"&gt;# ----Interpreting Basic Math and Bool Functions ---- &lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;+&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;add&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;-&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;    
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;subtract&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;=&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;equal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;lt;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;less&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rest&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;As you can see, I made use of Python's built in sum function which can
handle multiple operands. Since there isn't a similar function built in
for subtraction, I made one with the reduce function. Since this is the
first time I've used the reduce function I'll describe to you what it
does. Reduce takes two arguments: a function and a interable. I used a
list as an iterable, and I used lambda to define the function. Reduce
will take the function and will apply it cumulatively over the inputed
iterable. So, in my subtraction example, if I call subtract([4, 2, 1])
then it will calculate ((4 - 2) - 1) and will return 1.&lt;/p&gt;
&lt;p&gt;Notice that I didn't use the reduce function for evaluating boolean
statements. I tried to use it, but I was getting wonky results. This is
what I tried:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;equal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;    
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nb"&gt;reduce&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;lambda&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;To test this equal function, I input [1,1,1] and [2,2,2]. The expression
"equal([1, 1, 1])" would return True while "equal([2, 2, 2])"" would
return False. After taking the time to think about it, I realized what
was happening. When I set my input to [1, 1, 1], "(1 == 1)" will first
be evaluated and will return True. Then it will take True, and will
evalute "(True == 1)", which will again return True! Indeed, in Python
(and if I'm not mistaken, in most computer languages) True is 1 and
False is 0. This expalains why equal([2, 2, 2]) returns False. Python
would first evalute (2 == 2) returning True. Then it will evaluate "True
== 2" and return False. Pretty neat eh? Sometimes it pays off to take
the time to really think about how your code is working, and why it
isn't returning what you anticipate.&lt;/p&gt;
&lt;p&gt;In the end, I was able to define a successful equal function as
described above, by:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;equal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;    
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:]&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;[:&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Lets go through what this does when we input, say, args = [arg1, arg2,
arg3, arg4]. Two smaller lists are constructed: args[1:] = [arg2, arg3,
arg4] and arg[:-1] = [arg1, arg2, arg3]. Then the statement "[arg2,
arg3, arg4] == [arg1, arg2, arg3]" is evaluated. Notice that this is
essentially evaluating (arg2 == arg1 and arg3 == arg2 and arg4 == arg3),
which return True exactly when all the elements in the list are equal. I
really like this function because I feel its really simple and clean and
straight-forward.&lt;/p&gt;
&lt;p&gt;So, as you can see, there were moments this past week when I had to step
WAYYY back and re-write code I thought I was already done. But, in doing
so, I learned some really fun and cool things. Don't be discouraged if
you have to go back to something you thought you had finished! It could
turn out to be fun!&lt;/p&gt;</summary></entry><entry><title>Little Lessons</title><link href="http://lmontopo.github.io/little-lessons.html" rel="alternate"></link><updated>2014-10-27T04:00:00-04:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-10-27:little-lessons.html</id><summary type="html">&lt;p&gt;This blog post will be dedicated to some of the little (but important!)
lessons I've learned over the past week. Enjoy!&lt;/p&gt;
&lt;h4&gt;The list method "extend" returns None.&lt;/h4&gt;
&lt;p&gt;Before I explain this lesson, let me just back up for a second and
address the lingo "method". Only recently have I been able to add this word to my vocabulary, so
I'll take the time to explain it briefly here. A method is actually just a function that is associated
with a class. It is usually called on an instance of that class. If you've written some
code in Python you've probably already used methods, even if you didn't know the lingo. Now
lets talk about extend, a method invoked on lists! Here's a little example to illustrate what it does:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;extend&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Now, consider the following bit of code. Warning: It will produce an
error!&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; 
&lt;span class="o"&gt;&amp;gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;extend&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="mi"&gt;6&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;7&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;extend&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="mi"&gt;8&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="mi"&gt;9&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;I expected to get the list with entries 1 through 9 in return, but
instead I was greeted with the following message: "AttributeError: 'NoneType' object has no
attribute 'extend'"&lt;sup id="fnref:1"&gt;&lt;a class="footnote-ref" href="#fn:1" rel="footnote"&gt;1&lt;/a&gt;&lt;/sup&gt;. 
I was working with Julia Tufts at the time, and we were both intrigued by this
message. So we did a little playing around and realized that although the method 'extend' alters the list instance
it is invoked on, the method actually returns None. So when we extend doubly, in one line, as I did
above, list.extend([6,7]) returns None, and then we try to extend None with [8,9], producing an error. Cool!&lt;/p&gt;
&lt;h4&gt;Recursion.&lt;/h4&gt;
&lt;p&gt;For a while now I've had a vague idea of what recursion was, but my
vague idea caused me to believe I actually had a REAL idea of what it was. I didn't. Here's a little
example that Kuan Butts gave me which really cleared up my confusion: Suppose we want to write a
function that, when given a number, will write out that number as 1 + 1 + 1 .... etc. Here's a simple way to
use recursion to write that code:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5
6&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;plus_one&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;num&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;    
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;num&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;        
        &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="n"&gt;num&lt;/span&gt;    
    &lt;span class="k"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;1&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;+&amp;#39;&lt;/span&gt;        
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;plus_one&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;num&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Here, the "base case" is when num == 1. This is when the recursion
stops, and you start jumping back out of the layers of recursion.&lt;/p&gt;
&lt;h4&gt;Writing automated tests is useful!!&lt;/h4&gt;
&lt;p&gt;Previous to hacker school I had written some automated testing for the
sake of learning how to do it. I learned the very basics of how to write an automated test,
and then I never used this knowledge because I didn't see the point. I reasoned, "why would I waste
time writing code to test my code, when I could just test it on my own?" After all, I
had been testing my code on my own all along anyway, and I had been getting by just fine! And I wasn't
wrong! I really had been making out just fine. But then I got to hacker school and started working on
bigger, more involved projects. At some point I was having a hard time keeping track of all the things I
needed to test. I had a list of inputs to test, but many times I forgot exactly what each of them was
testing for. It started getting a little out of control, and it was at this point, that writing automated tests
became a valuable tool for me! It was magical to be able to write all of my tests in one file, with
comments, and be able to quickly run those tests every time I made a change to my project.&lt;/p&gt;
&lt;p&gt;So, the moral of the story is: If you are working on small projects and
you can keep track of your own testing and debugging, then by all means skip the automated tests! But know that they aren't
pointless. They have their uses, even if its not for your project.&lt;/p&gt;
&lt;h4&gt;What's a cache?&lt;/h4&gt;
&lt;p&gt;The other day I boldly decided to pair with Susan Steinman on her NY
Public Library app, even though I had no experience with the things she was doing. When we met up she told me she
was working on improving her "cache" and since I didn't know what a cache was, I asked. A cache, I discovered, is
just a database on a web application that stores stores previously requested data. Have you ever
noticed that when you search something on the internet that you've previously
searched, often the results come faster the second time around? This is caching at work! I'll use Susan's
app as an example. Suppose someone has used her app to search for the book 1984 by George
Orwell. Then, suppose I use her app and search for the same book. Her cache will already have
stored the results of the previous 1984 book search, so my inquiry can obtain the data directly from her cache instead of trying
to retrieve the information all over again from the NY Public Library database. Thanks Susan for
pairing with me!&lt;/p&gt;
&lt;div class="footnote"&gt;
&lt;hr /&gt;
&lt;ol&gt;
&lt;li id="fn:1"&gt;
&lt;p&gt;Ok so I realize now that this may be a bit confusing since the error
specifies that it is an attribute error instead of a &lt;em&gt;method&lt;/em&gt; error. I'm not
exactly clear on the difference between an attribute and a method, but I am pretty sure that a
method IS an attribute. I think the word "attribute" is just a more general term. So for now, we'll
go with that! Hopefully later I'll write a blog post to clear up the difference!&amp;#160;&lt;a class="footnote-backref" href="#fnref:1" rev="footnote" title="Jump back to footnote 1 in the text"&gt;&amp;#8617;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;</summary><category term="Recursion"></category><category term="Lists"></category></entry><entry><title>Interpreting the Interpreter: Episode 1</title><link href="http://lmontopo.github.io/interpreting-the-interpreter-episode-1.html" rel="alternate"></link><updated>2014-10-20T04:00:00-04:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-10-20:interpreting-the-interpreter-episode-1.html</id><summary type="html">&lt;p&gt;&lt;strong&gt;This episode will describe my experience in the initial phases of writing a Lisp interpreter.&lt;/strong&gt;
I will describe how I started, my thought processes as I progressed,
some of the code I wrote, how it worked, and, why,at day 3, I decided to start from scratch (almost). If you are only
interested in the final product,skip this episode! If, however, you'd like to get some insight as to how
a newbie handled thetask of writing an interpreter, read on!&lt;/p&gt;
&lt;p&gt;Step one: recruit a friend. (This just makes the process a little more
fun, plus its great to have someone to bounce ideas off of!) I recruited Kuan. We decided that we'd each write our own interpreter,
but that we'd talk through all the stepstogether, work side by side, and help each other debug. Our plan has
worked out great so far! &lt;/p&gt;
&lt;p&gt;To start, and we grabbed our computers,retreated to a quiet room, and sat quietly for a few moments,
contemplating the task at hand. I found myself asking, "What do interpreters do again?", and then
answering my own question with, "Right, they 'interpret'and then execute the code". We figured that before our computers could
execute any code, the code must first be separating into small elements, or &lt;strong&gt;tokens&lt;/strong&gt;. (The word
&lt;strong&gt;token&lt;/strong&gt; is the technical name referring to the smallest element of any programming language.) In separating the code this way, we would later be able to instruct our computers toscan through these elements in order, making sense of each element
individually, before executing the expressions they form together. We figured a good way to go about &lt;strong&gt;tokenizing&lt;/strong&gt;
would be to create a list of all of the tokens in the input. (Tokenizing is just the action of separating the
tokens. Don't worry if you aren't familiar with the terms token and
tokenization. I didn't know the meaning of these words until after I had already tokenized my
input!) This is the code Kuan and I came up with:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;holder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;input&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;replace&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;(&amp;#39;&lt;/span&gt; &lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;( &amp;#39;&lt;/span&gt; &lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;holder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;holder&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;replace&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;)&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;) &amp;#39;&lt;/span&gt; &lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;holder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;holder&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39; &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;holder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;filter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;lambda&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;holder&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="n"&gt;holder&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Here, 'holder' is what I decided to call the list that is constructed
from the input, because it 'holds' the input. Given, for example,&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="nb"&gt;input&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;quot;(/ (+ 3  2) (- 4 2))&amp;quot;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;This program will return the list:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;holder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;(&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;/&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;(&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;+&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;3&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;2&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;)&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; 
&lt;span class="s"&gt;&amp;#39;(&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;-&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;4&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;2&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;)&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;)&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Notice that before splitting the input, we added space around each of
the brackets. This accounts for the case where the user inputs two brackets side by side, or a number
right beside a bracket with no space.&lt;/p&gt;
&lt;p&gt;Having successfully created a list, holder, to hold the contents of our
input, we begun writing an algorithm to evaluate this content. For starters, Kuan
and I decided we would limit ourselves to making our interpreter work
for basic math expressions. After that we would gradually worry about interpreting more complicated inputs.&lt;/p&gt;
&lt;p&gt;When basic math is inputed the most nested expression should be
calculated first. We needed a way for the computer to find which math expression is the innermost one. We
created the following algorithm: &lt;/p&gt;
&lt;p&gt;1- Scan through the elements of holder from left to right in
search of the first ')'.&lt;/p&gt;
&lt;p&gt;2 - Begin scanning again, this time in search of the last '(' we hit
before the first ')'.  &lt;/p&gt;
&lt;p&gt;3- Extract whatever is inside of those brackets, and evaluate it. &lt;/p&gt;
&lt;p&gt;4- In holder, replace this innermost expression (including the brackets surrounding it) by its
result we just evaluated.  &lt;/p&gt;
&lt;p&gt;5- Start again at 1. &lt;/p&gt;
&lt;p&gt;This process would continue until there were no more brackets and expressions
left to evaluate. At this point, we would have evaluated the entire
expression.&lt;/p&gt;
&lt;p&gt;We were able to write a working piece of code that implemented this
algorithm, but it was sloppy and we'd only interpreted basic math. Kuan and I took a step back and
looked at how our algorithm would pan out moving forward. We
brainstormed how we could go about interpreting 'define' expressions and we realized
our current algorithm was going to get pretty complicated. Consider, for example, interpreting the expression:
'(define (func) (+ x 2))'.&lt;/p&gt;
&lt;p&gt;If our current algorithm encountered this as input, it would find
'(func)' and would get stuck trying to evaluate it.  It seemed that before even beginning our algorithm, we'd have to first
scan the entire input looking for the key word 'define'. Then, every
time we find 'define', we'd have to find the set of brackets containing the entire 'define'
expression. This in itself is kind of cumbersome, but we're only the beginning. Once our entire 'define' expression is
isolated, we'd have to search within this expression to find the our function's name. This would be done by scanning from left
to right and searching for the first ')' we come across, and then scanning again until we found its
corresponding '('. Then we'd have to remember the contents of these brackets, and begin scanning again to
find the defined function's expression. Once the expression was found, we'd have to
assign the contents of the previous two brackets as the name of the function's expression we just found.&lt;/p&gt;
&lt;p&gt;If you're getting confused, I don't blame you. Clearly this algorithm is
confusing. The reason it is confusing is because there are so many states the the computer is
required to keep track of at any moment. First we have to know we have found an expression
containing 'define', and that we are searching for the entire define expression. Then we isolate this expression, and
we have to remember that we are within the define expression and that we are searching for the right bracket that will contain the
function's name. Then we have to remember we have found the right bracket of the name of the function we are defining, and we're
searching for the left bracket containing the name, etc etc. SO MUCH TO KEEP TRACK OF!!!&lt;/p&gt;
&lt;p&gt;We turned to some resources online to see how they were approaching
these things. We found&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.hackerschool.com/blog/21-little-lisp-interpreter"&gt;Mary Cook's
article&lt;/a&gt;
and &lt;a href="http://norvig.com/lispy.html"&gt;Peter Norvig's article&lt;/a&gt; helpful.&lt;/p&gt;
&lt;p&gt;They had taken the parsing stage one step further than we
did. Instead of storing the brackets as elements of the list, they
created a version of "holder" which was a nested list. So, in the example where "(define (func) (x +
2))" is inputed, their code would turn it into the following array:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;define&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;func&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;+&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;x&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;2&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Kuan and I decided to figure out if/how this extra parsing step was
advantageous. After talking to Mary Cook in person about it (thanks Mary!) we got our answer:&lt;/p&gt;
&lt;p&gt;Using the nested method allowed us to not have to keep track of as many
sates! Indeed, at each stage of interpreting, we could simply look at the outermost list, look at the
operator, and then act accordingly.&lt;/p&gt;
&lt;p&gt;If we encountered a 'define' expression we could handle it as follows:
Given the new structure ofvholder we know that if our operator is define then holder[1] will be the
function's name. Likewise, we would know that the expression of this defined function could be
found at holder[2]. With this extra parsing step, there is no longer the need to scan through the list
searching for brackets, and keeping track of where we are. The nested structure of holder
replicates the actual structure of the input, and a lot of the pain and agony in our previous method is taken care of
for us here.&lt;/p&gt;
&lt;p&gt;Having clearly understood the differences between our algorithm and the
popular one found online, and having seen the benefits of theirs over ours, we decided scratch
what we had and start again. (Of course, the little tokenizer I described above could stay.)&lt;/p&gt;
&lt;p&gt;I would like to mention that I am HAPPY for the mistakes I made, as they
resulted in a great deal of learning. I am a big advocate of trying things your own way first, and
only changing your way once you've learned the merits of another way. Doing so results in a great
deal of learning you might otherwise miss out on.&lt;/p&gt;
&lt;p&gt;In the next episode, I hope to introduce to you the final product, and
explain how it works!&lt;/p&gt;
&lt;p&gt;Stay tuned!&lt;/p&gt;</summary></entry><entry><title>Interpreting the Interpreter: Episode 0</title><link href="http://lmontopo.github.io/interpreting-the-interpreter-episode-0.html" rel="alternate"></link><updated>2014-10-17T04:00:00-04:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-10-17:interpreting-the-interpreter-episode-0.html</id><summary type="html">&lt;p&gt;For a while now, I have been perplexed by the land of compilers and
interpreters. Thinking of these things sparks all sorts of questions in my mind. For instance, if
a compiler compiles my program, but the compiler is itself a program, doesn't something need to compile
the compiler? If so, wouldn't this chain just go on forever? And, if I were to write my own
computer language (which I could,theoretically, do) how would I go about doing so? And what's the difference between a
compiler and an interpreter?  Are interpreters and compilers things that I can write?!&lt;/p&gt;
&lt;p&gt;In this episode, I will begin by trying to answer some of these
questions. In later episodes I will describe my experiences writing a Lisp Interpreter. When I have
the interpreter all set up and running, I'll present it, and explain it. But before we get
to that, I think its worth while exploring what an interpreter IS, and how it differs from a
compiler.&lt;/p&gt;
&lt;p&gt;Compilers and interpreters serve a similar purpose: they take a piece of code written in some language that is foreign to your
computer, and they turn it into something that can be executed on your machine. It's the way in which these two programs
work that differentiates them.&lt;/p&gt;
&lt;p&gt;A &lt;strong&gt;compiler&lt;/strong&gt; works by taking the inputed piece of code (this is called
the &lt;strong&gt;source code&lt;/strong&gt;) and translating the entire document into &lt;strong&gt;machine code&lt;/strong&gt; (ie your machines native code,
written in 0s and 1s). The compiler produces a new file, called the &lt;strong&gt;object file&lt;/strong&gt; which can be
run directly on the machine, without any intermediate translation. So, if I write a piece of code in
C++, for example, then my compiler will read through the whole document, and will re-write
the set of instructions I've written in C++ into machine language instructions. (Usually some
sort of optimization is also involved, but we don't have to concern ourselves with that just
yet.) Since the code is then executed from the object file, and no longer interacts with the
initial C++ document, the C++ document could be deleted from your computer, and the code could
still be executed.&lt;/p&gt;
&lt;p&gt;An &lt;strong&gt;interpreter&lt;/strong&gt; on the other hand, executes the code directly as it
reads it. It doesn't create another translated file first. An interpreter will just read a line of
code, will transform it into something it understands, and then it it will execute it. I realize that this might all sound a
little vague, especially the part where I say the interpreter "transforms it into something it understands". What does &lt;em&gt;it&lt;/em&gt; understand, anyhow? Well, lets say we are writing a lisp interpreter in python (as I will be doing soon!) and the
interpreter comes across a line of code that reads "( + 1 1 )". Well, python doesn't understand this, but
if the interpreter changes it to "1 + 1", then python does understand this. &lt;/p&gt;
&lt;p&gt;Another thing I'd like to mention is that languages are not always
either "interpreted" or "compiled". Some languages, Python is one of them, are actually
implemented with both a compiler and an interpreter. Although people often refer to Python as an
'interpreted language', its implementation has 2 parts: First, the
python code is compiled into something called "byte-code". Then, an interpreter reads
and executes the byte-code!&lt;/p&gt;
&lt;p&gt;Cool, eh? Big thanks goes to &lt;a href="http://akaptur.github.io"&gt;Allison Kaptur&lt;/a&gt;
for explaining this to me and discussing interpreters and compilers with me! You rock!&lt;/p&gt;</summary></entry><entry><title>What I learned from Crista Lopes</title><link href="http://lmontopo.github.io/what-i-learned-from-crista-lopes.html" rel="alternate"></link><updated>2014-10-11T04:00:00-04:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-10-11:what-i-learned-from-crista-lopes.html</id><summary type="html">&lt;p&gt;The resident at Hacker School during my first week was Crista Lopes. She
has given some great lectures, and she's taught me some cool things!&lt;/p&gt;
&lt;h5&gt;Different Styles of Writing Code&lt;/h5&gt;
&lt;p&gt;On Monday night she spoke to us about coding styles, the topic of her
latest book. Crista explained that there are many different styles of code to work with, but that
often programmers get stuck in one way of coding. No style is "better" than another, but some work
better in certain situations. Crista suggests that when we set out to write a program we ask
ourselves, "what are our constraints?". Our constraint could be something we need to
minimize/avoid, or something we want to maximize/include. Examples of constraints include minimizing
the number of lines in our code, including functions, not including functions, and
maximizing efficiency. Theses constraints produce different "styles" of code. As a programmer, it is
good to familiarize ourselves with these different styles so that we can write in whichever
style is best suited for a particular project.&lt;/p&gt;
&lt;h5&gt;Data Types and Data Structures&lt;/h5&gt;
&lt;p&gt;On Wednesday Crista gave a really helpful introductory lecture on data
types and data structures.  Before this lecture I had little knowledge on the subject. I had heard
the words before but not really understood their meanings. Here is how she explained the two
concepts:&lt;/p&gt;
&lt;p&gt;A &lt;strong&gt;data type&lt;/strong&gt; is something more conceptual. It refers to our ideas of
what can be done with the data and what we want to do with the data.&lt;/p&gt;
&lt;p&gt;The term &lt;strong&gt;data structure&lt;/strong&gt;, on the other hand, refers to how we
&lt;em&gt;implement&lt;/em&gt; the data type. When we talk about data structure we are referring to how a "data type" is actually
storred in memory on our computer and how we can access that data.&lt;/p&gt;
&lt;p&gt;Crista talked about two common implementations of data in our computer:
the array, and the list. An array is a continuous portion of memory in our computer with
slots to put our data in. Each slot takes up the same amount of memory, and the total amount
of memory is fixed. Any slot of the array can be accessed directly. A list, on the other hand,
is NOT continuous. Different elements of the list can be stored in any location on the computer's
harddrive. Your computer knows which item is first in the list and each item will point to the
location in memory where the next item on the list is located.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Ok... but why does all of this matter?!&lt;/em&gt; Well, Crista provided us with
an example to illustrate why these things are important: Suppose we have a list of 500 contacts on
our computer. Our list contains the names and telephone numbers of each contact. We can call
this data type a "contact list". We have some choices as to how we can implement this
data. One option would be to use the list implementation described above. In this case, to find a
contact's telephone number we must scan through the list, starting from the top, until we arrive at
the name we are looking for.   Another option would be to implement our contact list as a hash
function.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;What is a hash function?!&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;I think the best way to illustrate the hash function is by example, the
way Crista described it. In our contact list scenario, an example of a hash function would be
something that acts as follows:&lt;/p&gt;
&lt;p&gt;For each contact, the computer associates to it the number of letters in
that contact's first name. Then an array, lets call it a, is created in memory. The nth cell of a
will "point" to a new list, containing only the contacts whose names have n letters. From there the
search starts from the top down, but the list is (hopefully) much smaller in size. Using this hash
function is much more efficient than just creating one list containing all of the contacts.
Indeed, computers can compute simple mathematical calculations like this one extremely
quickly, while scanning through lists is a more time consuming task.&lt;/p&gt;
&lt;p&gt;At this point, I'd like like to clarify something about data structures
and types: What certain programming languages refer to as "lists" and "arrays" are not
necessarily implemented as such. Likewise, what is implemented as a list or array or hash function in a
programming language is not necessarily called a list, array or hash function. I know that this is kind of
confusing, but here are some examples to clarify the situation. What Python calls a "list" of n elements is
actually implemented as an array with more than n slots. The array is created longer than necessary,
leaving several slots empty. This makes the array easier to append (ie. add elements to). Another
example in Python is the data type "dictionary", which is actually implemented as a hash
function.&lt;/p&gt;
&lt;h5&gt;Objects, Functions, Etc.&lt;/h5&gt;
&lt;p&gt;On Thursday, I came to Crista with a few questions about some
terminology that had been confusing me. I didn't really understand what was meant by the terms "functional
programming" and "object oriented programming". I wondered, "are these terms referring to
particular languages or are they referring to a style of writing code"? According to Crista,
these terms mostly apply to the style a program is written in. However, the terms are sometimes used to
describe languages.   (No wonder I was confused!) Crista explains that when you step far
enough away, you can see certain trends in programming languages too.
Some languages might tend towards the functional style, while others might tend towards
the object oriented style, for example. In reality, though, most languages pull from all different
ideas. Python is an example of this. Although Python is often called "object oriented",
Python also has functions! Most languages combine these ideas as does Python, though there are some
exceptions. Haskel, for example, is a purely functional programming language.&lt;/p&gt;
&lt;p&gt;This leads me to the next question: What is an object and why is it important? Although I've created classes
and objects in Python programs, I wasn't sure I really understood the point. Crista
provided me with an explanation that I liked. She explained how objects are constructs which
"wrap around" your data, so that you can't access it directly. This protects the data
so that it is less likely to be accidentally corrupted. There are other ways that data can
be protected if a language doesn't use classes, but this is just one of those ways.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Thanks Crista for visting Hacker School this week!!!!&lt;/strong&gt;&lt;/p&gt;</summary></entry><entry><title>The struggles I had setting up this site.</title><link href="http://lmontopo.github.io/the-struggles-i-had-setting-up-this-site.html" rel="alternate"></link><updated>2014-10-08T04:00:00-04:00</updated><author><name>Leta Montopoli</name></author><id>tag:lmontopo.github.io,2014-10-08:the-struggles-i-had-setting-up-this-site.html</id><summary type="html">&lt;p&gt;For me, setting up my blog was not easy. I think part of this was that I
was impatient, and part of this was because IT IS HARD! I ran into many weird error
messages and I began to get quite impatient and frustrated. Thankfully I got Allison to help
me, and together we figured out what was going on and got things up and running. Here I will
explain what went wrong for me and how I fixed it. If you encounter similar difficulties, hopefully this
article will help you.&lt;/p&gt;
&lt;p&gt;The main struggle I encountered began when I tried to publish my page
through Github. There are two different ways one can go about doing this: either as a
project page, or as a user page. Without knowing there was another option, I began
creating my blog as a Github project page. In order to do this, I had to create a repository
on Github, and then create branch of the repository called "gh-pages". "gh-pages" is where I
needed to push the pelican created "output" folder containing all the necessary html to
create the page. To make this push happen, I made use of the "gh-import" package which
can be installed using pip.&lt;/p&gt;
&lt;p&gt;Here is what needed to be done next:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="err"&gt;$&lt;/span&gt; &lt;span class="n"&gt;ghp&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="nn"&gt;output&lt;/span&gt;&lt;span class="err"&gt;$&lt;/span&gt; &lt;span class="n"&gt;git&lt;/span&gt; &lt;span class="n"&gt;push&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt;
&lt;span class="n"&gt;igin&lt;/span&gt; &lt;span class="n"&gt;gh&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;pages&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;Here, the first line commits changes made in my output folder to the
gh-branch of my LOCAL repository. (Local meaning, the repository on my own computer, not the
one store on Github.) The second line of this code pushes these changes to the remote
repository's gh-pages branch (ie. the branch of the repository stored on github).Then, in about ten
minutes time, my website was created with url https:://lmontopo.github.io/blog. (here, lmontopo
is my username on github, and blog was the repository I created).&lt;/p&gt;
&lt;p&gt;I wish this were the end of the story, but unfortunately it is not. What
I realized when my webpage was published is that none of pelican's styling information was
being received. My webpage was just a simple plain text webpage and it looked
extremely ugly. What was puzzling was that when I viewed the page source I saw a line in
the code specifying the location of the style sheet as:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;link&lt;/span&gt; &lt;span class="n"&gt;rel&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;stylesheet&amp;quot;&lt;/span&gt; &lt;span class="n"&gt;href&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;&amp;quot;/theme/css/main.css&amp;quot;&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;But when I clicked on this href, it couldn't find the file. Then I
looked in my github repository, and searched for that stylesheet file. I found it. It was
there. So why couldn't my computer find it? Well, it turns out that my computer was looking at the
wrong url. It expected my css style sheet to be found at "username.github.io/theme/css/main.css",
but in reality it was located at "username.github.io/repositoryname/theme/css/main.css".&lt;/p&gt;
&lt;p&gt;So, at this point I found out that there was such thing as a github user
page, and I decided to change my page to be one of those instead. I should
clarify that this was not necessary, and this was not the only way to solve my problem!
Had I decided to stay with the gh-pages website, I would have needed to change my default
root directory. This probably is quite easy, although to be honest I don't know exactly
how it is done.&lt;/p&gt;
&lt;p&gt;Since I decided to change to a user github page, this is how I
proceeded: I needed to create a new repository called username.github.io. To
github, this is a magic repository name. Github will know that you are publishing a user webpage
from the contents of this repository and it will do the work for you (just as gh-pages was
a magical branch name for the project pages site.) Then I deleted my old repository. Now, I
needed to tell my computer to connect remotely with this new repository as opposed to the old one.
(Just because the old repository is deleted, doesn't mean my computer won't try to find it.)
To do this I type in:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="err"&gt;$&lt;/span&gt; &lt;span class="n"&gt;git&lt;/span&gt; &lt;span class="n"&gt;remote&lt;/span&gt; &lt;span class="n"&gt;rm&lt;/span&gt; &lt;span class="n"&gt;origin&lt;/span&gt; 
&lt;span class="err"&gt;$&lt;/span&gt; &lt;span class="n"&gt;git&lt;/span&gt; &lt;span class="n"&gt;remote&lt;/span&gt; &lt;span class="n"&gt;add&lt;/span&gt; &lt;span class="n"&gt;username&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;github&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;io&lt;/span&gt; &lt;span class="n"&gt;https&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;//&lt;/span&gt;&lt;span class="n"&gt;github&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;com&lt;/span&gt;&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="n"&gt;username&lt;/span&gt;&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="n"&gt;username&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;github&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;io&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;The first line here removes the connection I had to the previous (now
deleted) repository on Github.  The second line adds a remote connection to the repository named
username.github.io found at https://github.com/username/username.github.io.&lt;/p&gt;
&lt;p&gt;Great, now all I had to do was push the contents of my local repository
to the main branch of my new remote repository as follows:&lt;/p&gt;
&lt;table class="highlighttable"&gt;&lt;tr&gt;&lt;td class="linenos"&gt;&lt;div class="linenodiv"&gt;&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;&lt;td class="code"&gt;&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="err"&gt;$&lt;/span&gt; &lt;span class="n"&gt;ghp&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="nn"&gt;output&lt;/span&gt;
&lt;span class="err"&gt;$&lt;/span&gt; &lt;span class="n"&gt;git&lt;/span&gt; &lt;span class="n"&gt;push&lt;/span&gt; &lt;span class="n"&gt;origin&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="n"&gt;gh&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;pages&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="n"&gt;master&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;

&lt;p&gt;This created a lovely new webpage for me! Notice, though, that here I
had to FORCE the push. Quite honestly, I am not clear on why this is happening. For now, I have
decided to create a new local branch called "writing" and I will use this for all of my
version control. This way I can continue to force push without worrying about anything being lost.
This may not be the most sophisticated way of handling things, but being quite new to git, I
am more than satisfied with this solution.&lt;/p&gt;
&lt;p&gt;Another little glitch that occurred along the way, and how I solved it:&lt;/p&gt;
&lt;p&gt;In the process of playing around with my computer, I somehow deleted the
pelicanconf.py file that pelican creates for you when you quickstart. This is the file
that specifies all of your settings. Since it was gone, I had lost my title, and the
default title "A Pelican Blog" appeared. Obviously, this wasn't desirable. This ended up being a
really easy fix because all I needed was to re-create this file and save it the
directory where my "content" folder is found. Then it integrates itself (somewhat magically) into the
html files. Just make sure that you have the correct formatting, as specified on
pelican's documentation site: &lt;a href="http://docs.getpelican.com/en/latest/settings.html"&gt;http://docs.getpelican.com/en/latest/settings.html&lt;/a&gt;&lt;/p&gt;</summary></entry></feed>