atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <id>https://faded.auspicious.space</id>
    <title>Typhoeus</title>
    <updated>2020-06-11T10:49:24.852Z</updated>
    <generator>https://github.com/jpmonette/feed</generator>
    <link rel="alternate" href="https://faded.auspicious.space"/>
    <link rel="self" href="https://faded.auspicious.space/atom.xml"/>
    <logo>https://faded.auspicious.space/images/avatar.png</logo>
    <icon>https://faded.auspicious.space/favicon.ico</icon>
    <rights>All rights reserved 2020, Typhoeus</rights>
    <entry>
        <title type="html"><![CDATA[The Nature of Lisp]]></title>
        <id>https://faded.auspicious.space/post/the-nature-of-lisp/</id>
        <link href="https://faded.auspicious.space/post/the-nature-of-lisp/">
        </link>
        <updated>2020-05-31T13:07:56.000Z</updated>
        <summary type="html"><![CDATA[<blockquote>
<p><a href="http://www.defmacro.org/ramblings/lisp.html">The Nature of Lisp</a></p>
</blockquote>
]]></summary>
        <content type="html"><![CDATA[<blockquote>
<p><a href="http://www.defmacro.org/ramblings/lisp.html">The Nature of Lisp</a></p>
</blockquote>
<!-- more -->
<h1 id="introduction">Introduction</h1>
<p>When I first stumbled into Lisp advocacy on various corners of the web I was already an experienced programmer. At that point I had grokked what seemed at the time a wide range of programming languages. I was proud to have the usual suspects (C++, Java, C#, etc.) on my service record and was under impression that I knew everything there is to know about programming languages. I couldn't have possibly been more wrong.</p>
<p>My initial attempt to learn Lisp came to a crashing halt as soon as I saw some sample code. I suppose the same thought ran through my mind that ran through thousands of other minds who were ever in my shoes: &quot;Why on Earth would anyone want to use a language with such horrific syntax?!&quot; I couldn't be bothered to learn a language if its creators couldn't be bothered to give it a pleasant syntax. After all, I was almost blinded by the infamous Lisp parentheses!</p>
<p>The moment I regained my sight I communicated my frustrations to some members of the Lisp sect. Almost immediately I was bombarded by a standard set of responses: Lisp's parentheses are only a superficial matter, Lisp has a huge benefit of code and data being expressed in the same manner (which, obviously, is a huge improvement over XML), Lisp has tremendously powerful metaprogramming facilities that allow programs to write code and modify themselves, Lisp allows for creation of mini-languages specific to the problem at hand, Lisp blurs the distinction between run time and compile time, Lisp, Lisp, Lisp... The list was very impressive. Needless to say none of it made sense. Nobody could illustrate the usefulness of these features with specific examples because these techniques are supposedly only useful in large software systems. After many hours of debating that conventional programming languages do the job just fine, I gave up. I wasn't about to invest months into learning a language with a terrible syntax in order to understand obscure features that had no useful examples. My time has not yet come.</p>
<p>For many months the Lisp advocates pressed on. I was baffled. Many extremely intelligent people I knew and had much respect for were praising Lisp with almost religious dedication. There had to be something there, something I couldn't afford not to get my hands on! Eventually my thirst for knowledge won me over. I took the plunge, bit the bullet, got my hands dirty, and began months of mind bending exercises. It was a journey on an endless lake of frustration. I turned my mind inside out, rinsed it, and put it back in place. I went through seven rings of hell and came back. And then I got it.</p>
<p>The enlightenment came instantaneously. One moment I understood nothing, and the next moment everything clicked into place. I've achieved nirvana. Dozens of times I heard Eric Raymond's statement quoted by different people: &quot;Lisp is worth learning for the profound enlightenment experience you will have when you finally get it; that experience will make you a better programmer for the rest of your days, even if you never actually use Lisp itself a lot.&quot; I never understood this statement. I never believed it could be true. And finally, after all the pain, it made sense! There was more truth to it than I ever could have imagined. I've achieved an almost divine state of mind, an instantaneous enlightenment experience that turned my view of computer science on its head in less than a single second.</p>
<p>That very second I became a member of the Lisp cult. I felt something a ninjitsu master must feel: I had to spread my newfound knowledge to at least ten lost souls in the course of my lifetime. I took the usual path. I was rehashing the same arguments that were given to me for years (only now they actually made sense!), hoping to convert unsuspecting bystanders. It didn't work. My persistence sparked a few people's interest but their curiosity dwindled at the mere sight of sample Lisp code. Perhaps years of advocacy would forge a few new Lispers, but I wasn't satisfied. There had to be a better way.</p>
<p>I gave the matter careful thought. Is there something inherently hard about Lisp that prevents very intelligent, experienced programmers from understanding it? No, there isn't. After all, I got it, and if I can do it, anybody can. Then what is it that makes Lisp so hard to understand? The answer, as such things usually do, came unexpectedly. Of course! Teaching anybody anything involves building advanced concepts on top of concepts they already understand! If the process is made interesting and the matter is explained properly the new concepts become as intuitive as the original building blocks that aided their understanding. That was the problem! Metaprogramming, code and data in one representation, self-modifying programs, domain specific mini-languages, none of the explanations for these concepts referenced familiar territory. How could I expect anyone to understand them! No wonder people wanted specific examples. I could as well have been speaking in Martian!</p>
<p>I shared my ideas with fellow Lispers. &quot;Well, of course these concepts aren't explained in terms of familiar territory&quot;, they said. &quot;They are so different, they're unlike anything these people have learned before.&quot; This was a poor excuse. &quot;I do not believe this to be true&quot;, I said. The response was unanimous: &quot;Why don't you give it a try?&quot; So I did. This article is a product of my efforts. It is my attempt to explain Lisp in familiar, intuitive concepts. I urge brave souls to read on. Grab your favorite drink. Take a deep breath. Prepare to be blown away. Oh, and may the Force be with you.</p>
<h1 id="xml-reloaded">XML Reloaded</h1>
<p>A thousand mile journey starts with a single step. A journey to enlightenment is no exception and our first step just happens to be XML. What more could possibly be said about XML that hasn't already been said? It turns out, quite a bit. While there's nothing particularly interesting about XML itself, its relationship to Lisp is fascinating. XML is the all too familiar concept that Lisp advocates need so much. It is our bridge to conveying understanding to regular programmers. So let's revive the dead horse, take out the stick, and venture into XML wilderness that no one dared venture into before us. It's time to see the all too familiar moon from the other side.</p>
<p>Superficially XML is nothing more than a standardized syntax used to express arbitrary hierarchical data in human readable form. To-do lists, web pages, medical records, auto insurance claims, configuration files are all examples of potential XML use. Let's use a simple to-do list as an example (in a couple of sections you'll see it in a whole new light):</p>
<pre><code class="language-xml">&lt;todo name=&quot;housework&quot;&gt;
    &lt;item priority=&quot;high&quot;&gt;Clean the house.&lt;/item&gt;
    &lt;item priority=&quot;medium&quot;&gt;Wash the dishes.&lt;/item&gt;
    &lt;item priority=&quot;medium&quot;&gt;Buy more soap.&lt;/item&gt;
&lt;/todo&gt;
</code></pre>
<p>What happens if we unleash our favorite XML parser on this to-do list? Once the data is parsed, how is it represented in memory? The most natural representation is, of course, a tree - a perfect data structure for hierarchical data. After all is said and done, XML is really just a tree serialized to a human readable form. Anything that can be represented in a tree can be represented in XML and vice versa. I hope you understand this idea. It's very important for what's coming next.</p>
<p>Let's take this a little further. What other type of data is often represented as a tree? At this point the list is as good as infinite so I'll give you a hint at what I'm getting at - try to remember your old compiler course. If you have a vague recollection that source code is stored in a tree after it's parsed, you're on the right track. Any compiler inevitably parses the source code into an abstract syntax tree. This isn't surprising since source code is hierarchical: functions contain arguments and blocks of code. Blocks of code contain expressions and statements. Expressions contain variables and operators. And so it goes.</p>
<p>Let's apply our corollary that any tree can easily be serialized into XML to this idea. If all source code is eventually represented as a tree, and any tree can be serialized into XML, then all source code can be converted to XML, right? Let's illustrate this interesting property by a simple example. Consider the function below:</p>
<pre><code class="language-cpp">int add(int arg1, int arg2)
{
    return arg1 + arg2;
}
</code></pre>
<p>Can you convert this function definition to its XML equivalent? Turns out, it's reasonably simple. Naturally there are many ways to do this. Here is one way the resulting XML can look like:</p>
<pre><code class="language-xml">&lt;define-function return-type=&quot;int&quot; name=&quot;add&quot;&gt;
    &lt;arguments&gt;
        &lt;argument type=&quot;int&quot;&gt;arg1&lt;/argument&gt;
        &lt;argument type=&quot;int&quot;&gt;arg2&lt;/argument&gt;
    &lt;/arguments&gt;
    &lt;body&gt;
        &lt;return&gt;
            &lt;add value1=&quot;arg1&quot; value2=&quot;arg2&quot; /&gt;
        &lt;/return&gt;
    &lt;/body&gt;
&lt;/define&gt;
</code></pre>
<p>We can go through this relatively simple exercise with any language. We can turn any source code into XML, and we can transform the resulting XML back to original source code. We can write a converter that turns Java into XML and a converter that turns XML back to Java. We could do the same for C++. (In case you're wondering if anyone is crazy enough to do it, take a look at <a href="http://www.gccxml.org/">GCC-XML</a>). Furthermore, for languages that share common features but use different syntax (which to some extent is true about most mainstream languages) we could convert source code from one language to another using XML as an intermediary representation. We could use our Java2XML converter to convert a Java program to XML. We could then run an XML2CPP converter on the resulting XML and turn it into C++ code. With any luck (if we avoid using features of Java that don't exist in C++) we'll get a working C++ program. Neat, eh?</p>
<p>All this effectively means that we can use XML for generic storage of source code. We'd be able to create a whole class of programming languages that use uniform syntax, as well as write transformers that convert existing source code to XML. If we were to actually adopt this idea, compilers for different languages wouldn't need to implement parsers for their specific grammars - they'd simply use an XML parser to turn XML directly into an abstract syntax tree.</p>
<p>By now you're probably wondering why I've embarked on the XML crusade and what it has to do with Lisp (after all, Lisp was created about thirty years before XML). I promise that everything will become clear soon enough. But before we take our second step, let's go through a small philosophical exercise. Take a good look at the XML version of our &quot;add&quot; function above. How would you classify it? Is it data or code? If you think about it for a moment you'll realize that there are good reasons to put this XML snippet into both categories. It's XML and it's just information encoded in a standardized format. We've already determined that it can be generated from a tree data structure in memory (that's effectively what GCC-XML does). It's lying around in a file with no apparent way to execute it. We can parse it into a tree of XML nodes and do various transformations on it. It's data. But wait a moment! When all is said and done it's the same &quot;add&quot; function written with a different syntax, right? Once parsed, its tree could be fed into a compiler and we could execute it. We could easily write a small interpreter for this XML code and we could execute it directly. Alternatively, we could transform it into Java or C++ code, compile it, and run it. It's code.</p>
<p>So, where are we? Looks like we've just arrived to an interesting point. A concept that has traditionally been so hard to understand is now amazingly simple and intuitive. Code is also always data! Does it mean that data is also always code? As crazy as this sounds this very well might be the case. Remember how I promised that you'll see our to-do list in a whole new light? Let me reiterate on that promise. But we aren't ready to discuss this just yet. For now let's continue walking down our path.</p>
<p>A little earlier I mentioned that we could easily write an interpreter to execute our XML snippet of the add function. Of course this sounds like a purely theoretical exercise. Who in their right mind would want to do that for practical purposes? Well, it turns out quite a few people would disagree. You've likely encountered and used their work at least once in your career, too. Do I have you out on the edge of your seat? If so, let's move on!</p>
<h1 id="ant-reloaded">Ant Reloaded</h1>
<p>Now that we've made the trip to the dark side of the moon, let's not leave quite yet. We may still learn something by exploring it a little more, so let's take another step. We begin by closing our eyes and remembering a cold rainy night in the winter of 2000. A prominent developer by the name of [James Duncan Davidson][1] was hacking his way through <a href="http://tomcat.apache.org/">Tomcat</a> servlet container. As the time came to build the changes he carefully saved all his files and ran make. Errors. Lots of errors. Something was wrong. After careful examination James exclaimed: &quot;Is my command not executing because I have a space in front of my tab?!&quot; Indeed, this was the problem. Again. James has had enough. He could sense the full moon through the clouds and it made him adventurous. He created a fresh Java project and quickly hacked together a simple but surprisingly useful utility. This spark of genius used Java property files for information on how to build the project. James could now write the equivalent of the makefile in a nice format without worrying about the damned spaces ever again. His utility did all the hard work by interpreting the property file and taking appropriate actions to build the project. It was neat. Another Neat Tool. <a href="http://ant.apache.org/">Ant</a>.</p>
<p>After using Ant to build Tomcat for a few months it became clear that Java property files are not sufficient to express complicated build instructions. Files needed to be checked out, copied, compiled, sent to another machine, and unit tested. In case of failure e-mails needed to be sent out to appropriate people. In case of success &quot;Bad to the Bone&quot; needed to be played at the highest possible volume. At the end of the track volume had to be restored to its original level. Yes, Java property files didn't cut it anymore. James needed a more flexible solution. He didn't feel like writing his own parser (especially since he wanted an industry standard solution). XML seemed like a reasonable alternative. In a couple of days Ant was ported to XML. It was the best thing since sliced bread.</p>
<p>So how does Ant work? It's pretty simple. It takes an XML file with specific build instructions (you decide if they're data or code) and interprets them by running specialized Java code for each XML element. It's actually much simpler than it sounds. A simple XML instruction like the one below causes a Java class with an equivalent name to be loaded and its code to be executed.</p>
<pre><code class="language-xml">&lt;copy todir=&quot;../new/dir&quot;&gt;
    &lt;fileset dir=&quot;src_dir&quot;/&gt;
&lt;/copy&gt;
</code></pre>
<p>The snippet above copies a source directory to a destination directory. Ant locates a &quot;copy&quot; task (a Java class, really), sets appropriate parameters (todir and fileset) by calling appropriate Java methods and then executes the task. Ant comes with a set of core tasks and anyone can extend it with tasks of their own simply by writing Java classes that follow certain conventions. Ant finds these classes and executes them whenever XML elements with appropriate names are encountered. Pretty simple. Effectively Ant accomplishes what we were talking about in the previous section: it acts as an interpreter for a language that uses XML as its syntax by translating XML elements to appropriate Java instructions. We could write an &quot;add&quot; task and have Ant execute it when it encounters the XML snippet for addition presented in the previous section! Considering that Ant is an extremely popular project, the ideas presented in the previous section start looking more sane. After all, they're being used every day in what probably amounts to thousands of companies!</p>
<p>So far I've said nothing about why Ant actually goes through all the trouble of interpreting XML. Don't try to look for the answer on its website either - you'll find nothing of value. Nothing relevant to our discussion, anyway. Let's take another step. It's time to find out why.</p>
<h1 id="why-xml">Why XML?</h1>
<p>Sometimes right decisions are made without full conscious understanding of all the issues involved. I'm not sure if James knew why he chose XML - it was likely a subconscious decision. At the very least, the reasons I saw on Ant's website for using XML are all the wrong reasons. It appears that the main concerns revolved around portability and extensibility. I fail to see how XML helps advance these goals in Ant's case. What is the advantage of using interpreted XML over simple Java source code? Why not create a set of classes with a nice API for commonly used tasks (copying directories, compiling, etc.) and using those directly from Java source code? This would run on every platform that runs Java (which Ant requires anyway), it's infinitely extensible, and it has the benefit of having a more pleasant, familiar syntax. So why XML? Can we find a good reason for using it?</p>
<p>It turns out that we can (although as I mentioned earlier I'm not sure if James was consciously aware of it). XML has the property of being far more flexible in terms of introduction of semantic constructs than Java could ever hope to be. Don't worry, I'm not falling into the trap of using big words to describe incomprehensible concepts. This is actually a relatively simple idea, though it may take some effort to explain. Buckle your seat-belt. We're about to make a giant leap towards achieving nirvana.</p>
<p>How can we represent 'copy' example above in Java code? Here's one way to do it:</p>
<pre><code class="language-java">CopyTask copy = new CopyTask();
Fileset fileset = new Fileset();

fileset.setDir(&quot;src_dir&quot;);
copy.setToDir(&quot;../new/dir&quot;);
copy.setFileset(fileset);

copy.execute();
</code></pre>
<p>The code is almost the same, albeit a little longer than the original XML. So what's different? The answer is that the XML snippet introduces a special semantic construct for copying. If we could do it in Java it would look like this:</p>
<pre><code class="language-java">copy(&quot;../new/dir&quot;)
{
    fileset(&quot;src_dir&quot;);
}
</code></pre>
<p>Can you see the difference? The code above (if it were possible in Java) is a special operator for copying files - similar to a for loop or a new foreach construct introduced in Java 5. If we had an automatic converter from XML to Java it would likely produce the above gibberish. The reason for this is that Java's accepted syntax tree grammar is fixed by the language specification - we have no way of modifying it. We can add packages, classes, methods, but we cannot extend Java to make addition of new operators possible. Yet we can do it to our heart's content in XML - its syntax tree isn't restricted by anything except our interpreter! If the idea is still unclear, consider introducing a special operator 'unless' to Java:</p>
<pre><code class="language-java">unless(someObject.canFly())
{
    someObject.transportByGround();
}
</code></pre>
<p>In the previous two examples we extend the Java language to introduce an operator for copying files and a conditional operator unless. We would do this by modifying the abstract syntax tree grammar that Java compiler accepts. Naturally we cannot do it with standard Java facilities, but we can easily do it in XML. Because our XML interpreter parses the abstract syntax tree that results from it, we can extend it to include any operator we like.</p>
<p>For complex operators this ability provides tremendous benefits. Can you imagine writing special operators for checking out source code, compiling files, running unit testing, sending email? Try to come up with some. If you're dealing with a specialized problem (in our case it's building projects) these operators can do wonders to decrease the amount of code you have to type and to increase clarity and code reuse. Interpreted XML makes this extremely easy to accomplish because it's a simple data file that stores hierarchical data. We do not have this option in Java because it's hierarchical structure is fixed (as you will soon find out, we do have this option in Lisp). Perhaps this is one of the reasons why Ant is so successful?</p>
<p>I urge you to take a look at recent evolution of Java and C# (especially the recently released specification for C# 3.0). The languages are being evolved by abstracting away commonly used functionality and adding it in the form of operators. New C# operators for built-in queries is one example. This is accomplished by relatively traditional means: language creators modify the accepted abstract syntax tree and add implementations of certain features. Imagine the possibilities if the programmer could modify the abstract syntax tree himself! Whole new sub-languages could be built for specialized domains (for example a language for building projects, like Ant). Can you come up with other examples? Think about these concepts for a bit, but don't worry about them too much. We'll come back to these issues after introducing a few more ideas. By then things will be a little more clear.</p>
<h1 id="almost-lisp">Almost Lisp</h1>
<p>Let's forget about the operator business for the moment and try to expand our horizons beyond the constraints of Ant's design. I mentioned earlier that Ant can be extended by writing conventional Java classes. Ant interpreter then attempts to match XML elements to appropriately named Java classes and if the match is found the task is executed. An interesting question begs to be asked. Why not extend Ant in Ant itself? After all, core tasks contain a lot of conventional programming language constructs ('if' being a perfect example). If Ant provided constructs to develop tasks in Ant itself we'd reach a higher degree of portability. We'd be dependent on a core set of tasks (a standard library, if you will) and we wouldn't care if Java runtime is present: the core set could be implemented in anything. The rest of the tasks would be built on top of the core using Ant-XML itself. Ant would then become a generic, extensible, XML-based programming language. Consider the possibilities:</p>
<pre><code class="language-xml">&lt;task name=&quot;Test&quot;&gt;
    &lt;echo message=&quot;Hello World!&quot;/&gt;
&lt;/task&gt;
&lt;Test /&gt;
</code></pre>
<p>If ant supported the &quot;task&quot; construct, the example above would print &quot;Hello World!&quot;. In fact, we could write a &quot;task&quot; task in Java and make Ant able to extend itself using Ant-XML! Ant would then be able to build more complicated primitives on top of simple ones, just like any other programming language! This is an example of &quot;XML&quot; based programming language we were talking about in the beginning of this tutorial. Not very useful (can you tell why?) but pretty damn cool.</p>
<p>By the way, take a look at our 'Test' task once again. Congratulations. You're looking at Lisp code. What on Earth am I talking about? It doesn't look anything like Lisp? Don't worry, we'll fix that in a bit. Confused? Good. Let's clear it all up!</p>
<h1 id="a-better-xml">A Better XML</h1>
<p>I mentioned in the previous section that self-extending Ant wouldn't be very useful. The reason for that is XML's verbosity. It's not too bad for data files but the moment you try writing reasonably complex code the amount of typing you have to do quickly starts to get in the way and progresses to becoming unusable for any real project. Have you ever tried writing Ant build scripts? I have, and once they get complex enough having to do it in XML becomes really annoying. Imagine having to type almost everything in Java twice because you have to close every element. Wouldn't that drive you nuts?</p>
<p>The solution to this problem involves using a less verbose alternative to XML. Remember, XML is just a format for representing hierarchical data. We don't have to use XML's angle brackets to serialize trees. We could come up with many other formats. One such format (incidentally, the one Lisp uses) is called an s-expression. S-expressions accomplish the same goals as XML. They're just a lot less verbose, which makes them much better suited for typing code. I will explain s-expressions in a little while, but before I do I have to clear up a few things about XML. Let's consider our XML example for copying files:</p>
<pre><code class="language-xml">&lt;copy todir=&quot;../new/dir&quot;&gt;
    &lt;fileset dir=&quot;src_dir&quot;/&gt;
&lt;/copy&gt;
</code></pre>
<p>Think of what the parse tree of this snippet would look like in memory. We'd have a 'copy' node that contains a fileset node. But what about attributes? How do they fit into our picture? If you've ever used XML to describe data and wondered whether you should use an element or an attribute, you're not alone. Nobody can really figure this out and doing it right tends to be black magic rather than science. The reason for that is that attributes are really subsets of elements. Anything attributes can do, elements can do as well. The reason attributes were introduced is to curb XML's verbosity. Take a look at another version of our 'copy' snippet:</p>
<pre><code class="language-xml">&lt;copy&gt;
    &lt;todir&gt;../new/dir&lt;/todir&gt;
    &lt;fileset&gt;
        &lt;dir&gt;src_dir&lt;/dir&gt;
    &lt;/fileset&gt;
&lt;/copy&gt;
</code></pre>
<p>The two snippets hold exactly the same information. However, we use attributes to avoid typing the same thing more than once. Imagine if attributes weren't part of XML specification. Writing anything in XML would drive us nuts!</p>
<p>Now that we got attributes out of the way, let's look at s-expressions. The reason we took this detour is that s-expressions do not have attributes. Because they're a lot less verbose, attributes are simply unnecessary. This is one thing we need to keep in mind when transforming XML to s-expressions. Let's take a look at an example. We could translate above snippet to s-expressions like this:</p>
<pre><code class="language-lisp">(copy
    (todir &quot;../new/dir&quot;)
    (fileset (dir &quot;src_dir&quot;)))
</code></pre>
<p>Take a good look at this representation. What's different? Angle brackets seem to be replaced by parentheses. Instead of enclosing each element into a pair of parentheses and then closing each element with a &quot;(/element)&quot; we simply skip the second parenthesis in &quot;(element&quot; and proceed. The element is then closed like this: &quot;)&quot;. That's it! The translation is natural and very simple. It's also a lot easier to type. Do parentheses blind first time users? Maybe, but now that we're understand the reasoning behind them they're a lot easier to handle. At the very least they're better than arthritis inducing verbosity of XML. After you get used to s-expressions writing code in them is not only doable but very pleasant. And they provide all the benefits of writing code in XML (many of which we're yet to explore). Let's take a look at our 'task' code in something that looks a lot more like lisp:</p>
<pre><code class="language-lisp">(task (name &quot;Test&quot;)
    (echo (message &quot;Hello World!&quot;)))

(Test)
</code></pre>
<p>S-expressions are called lists in Lisp lingo. Consider our 'task' element above. If we rewrite it without a line break and with comas instead of spaces it's starting to look surprisingly like a list of elements and other lists (the formatting is added to make it easier to see nested lists):</p>
<pre><code class="language-lisp">(task, (name, &quot;test&quot;), (echo, (message, &quot;Hello World!&quot;)))
</code></pre>
<p>We could do the same with XML. Of course the line above isn't really a list, it's a tree, just like its XML-alternative. Don't let references to lists confuse you, it's just that lists that contain other lists and trees are effectively the same thing. Lisp may stand for List Processing, but it's really tree processing - no different than processing XML nodes.</p>
<p>Whew. After much rambling we finally got to something that looks like Lisp (and is Lisp, really). By now the mysterious Lisp parentheses as well as some claims made by Lisp advocates should become more clear. But we still have a lot of ground to cover. Ready? Let's move on!</p>
<h1 id="c-macros-reloaded">C Macros Reloaded</h1>
<p>By now you must be tired of all the XML talk. I'm tired of it as well. It's time to take a break from all the trees, s-expressions, and Ant business. Instead, let's go back to every programmer's roots. It's time to talk about C preprocessor. What's C got to do with anything, I hear you ask? Well, we now know enough to get into metaprogramming and discuss code that writes other code. Understanding this tends to be hard since all tutorials discuss it in terms of languages that you don't know. But there is nothing hard about the concept. I believe that a metaprogramming discussion based on C will make the whole thing much easier to understand. So, let's see (pun intended).</p>
<p>Why would anyone want to write a program that writes programs? How can we use something like this in the real world? What on Earth is metaprogramming, anyway? You already know all the answers, you just don't know it yet. In order to unlock the hidden vault of divine knowledge let's consider a rather mundane task of simple database access from code. We've all been there. Writing SQL queries all over the code to modify data within tables turns into repetitive hell soon enough. Even with the new C# 3.0 LINQ stuff this is a huge pain. Writing a full SQL query (albeit with a nice built in syntax) to get someone's name or to modify someone's address isn't exactly a programmer's idea of comfort. What do we do to solve these problems? Enter data access layers.</p>
<p>The idea is simple enough. You abstract database access (at least trivial queries, anyway) by creating a set of classes that mirror the tables in the database and use accessor methods to execute actual queries. This simplifies development tremendously - instead of writing SQL queries we make simple method calls (or property assignments, depending on your language of choice). Anyone who has ever used even the simplest of data access layers knows how much time it can save. Of course anyone who has ever written one knows how much time it can kill - writing a set of classes that mirror tables and convert accessors to SQL queries takes a considerable chunk of time. This seems especially silly since most of the work is manual: once you figure out the design and develop a template for your typical data access class you don't need to do any thinking. You just write code based on the same template over and over and over and over again. Many people figured out that there is a better way - there are plenty of tools that connect to the database, grab the schema, and write code for you based on a predefined (or a custom) template.</p>
<p>Anyone who has ever used such a tool knows what an amazing time saver it can be. In a few clicks you connect the tool to the database, get it to generate the data access layer source code, add the files to your project and voilà - ten minutes worth of work do a better job than hundreds of man-hours that were required previously. What happens if your database schema changes? Well, you just have to go through this short process again. Of course some of the best tools let you automate this - you simply add them as a part of your build step and every time you compile your project everything is done for you automatically. This is perfect! You barely have to do anything at all. If the schema ever changes your data access layer code updates automatically at compile time and any obsolete access in your code will result in compiler errors!</p>
<p>Data access layers are one good example, but there are plenty of others. From boilerplate GUI code, to web code, to COM and CORBA stubs, to MFC and ATL, - there are plenty of examples where the same code is written over and over again. Since writing this code is a task that can be automated completely and a programmer's time is far more expensive than CPU time, plenty of tools have been created that generate this boilerplate code automatically. What are these tools, exactly? Well, they are programs that write programs. They perform a simple task that has a mysterious name of metaprogramming. That's all there is to it.</p>
<p>We could create and use such tools in millions of scenarios but more often than not we don't. What it boils down to is a subconscious calculation - is it worth it for me to create a separate project, write a whole tool to generate something, and then use it, if I only have to write these very similar pieces about seven times? Of course not. Data access layers and COM stubs are written hundreds, thousands of times. This is why there are tools for them. For similar pieces of code that repeat only a few times, or even a few dozen times, writing code generation tools isn't even considered. The trouble to create such a tool more often than not far outweighs the benefit of using one. If only creating such tools was much easier, we could use them more often, and perhaps save many hours of our time. Let's see if we can accomplish this in a reasonable manner.</p>
<p>Surprisingly C preprocessor comes to the rescue. We've all used it in C and C++. On occasion we all wish Java had it. We use it to execute simple instructions at compile time to make small changes to our code (like selectively removing debug statements). Let's look at a quick example:</p>
<pre><code class="language-cpp">#define triple(X)    X + X + X
</code></pre>
<p>What does this line do? It's a simple instruction written in the preprocessor language that instructs it to replace all instances of <code>triple(X)</code> with <code>X + X + X</code>. For example all instances of '<code>triple(5)</code>' will be replaced with '<code>5 + 5 + 5</code>' and the resulting code will be compiled by the C compiler. We're really doing a very primitive version of code generation here. If only C preprocessor was a little more powerful and included ways to connect to the database and a few more simple constructs, we could use it to develop our data access layer right there, from within our program! Consider the following example that uses an imaginary extension of the C preprocessor:</p>
<pre><code>#get-db-schema(&quot;127.0.0.1, un, pwd&quot;);
#iterate-through-tables
#for-each-table
    class #table-name
    {
    };
#end-for-each
</code></pre>
<p>We've just connected to the database schema, iterated through all the tables, and created an empty class for each. All in a couple of lines right within our source code! Now every time we recompile the file where above code appears we'll get a freshly built set of classes that automatically update based on the schema. With a little imagination you can see how we could build a full data access layer straight from within our program, without the use of any external tools! Of course this has a certain disadvantage (aside from the fact that such an advanced version of C preprocessor doesn't exist) - we'd have to learn a whole new &quot;compile-time language&quot; to do this sort of work. For complex code generation this language would have to be very complex as well, it would have to support many libraries and language constructs. For example, if our generated code depended on some file located at some ftp server the preprocessor would have to be able to connect to ftp. It's a shame to create and learn a new language just to do this. Especially since there are so many nice languages already out there. Of course if we add a little creativity we can easily avoid this pitfall.</p>
<p>Why not replace the preprocessor language with C/C++ itself? We'd have full power of the language at compile time and we'd only need to learn a few simple directives to differentiate between compile time and runtime code!</p>
<pre><code class="language-cpp">&lt;%
    cout &lt;&lt; &quot;Enter a number: &quot;;
    cin &gt;&gt; n;
%&gt;
for(int i = 0; i &lt; &lt;%= n %&gt;; i++)
{
    cout &lt;&lt; &quot;hello&quot; &lt;&lt; endl;
}
</code></pre>
<p>Can you see what happens here? Everything that's between &lt;% and %&gt; tags runs when the program is compiled. Anything outside of these tags is normal code. In the example above you'd start compiling your program in the development environment. The code between the tags would be compiled and then ran. You'd get a prompt to enter a number. You'd enter one and it would be placed inside the for loop. The for loop would then be compiled as usual and you'd be able to execute it. For example, if you'd enter 5 during the compilation of your program, the resulting code would look like this:</p>
<pre><code class="language-cpp">for(int i = 0; i &lt; 5; i++)
{
    cout &lt;&lt; &quot;hello&quot; &lt;&lt; endl;
}
</code></pre>
<p>Simple and effective. No need for a special preprocessor language. We get full power of our host language (in this case C/C++) at compile time. We could easily connect to a database and generate our data access layer source code at compile time in the same way JSP or ASP generate HTML! Creating such tools would also be tremendously quick and simple. We'd never have to create new projects with specialized GUIs. We could inline our tools right into our programs. We wouldn't have to worry about whether writing such tools is worth it because writing them would be so fast - we could save tremendous amounts of time by creating simple bits of code that do mundane code generation for us!</p>
<h1 id="hello-lisp">Hello, Lisp!</h1>
<p>Everything we've learned about Lisp so far can be summarized by a single statement: Lisp is executable XML with a friendlier syntax. We haven't said a single word about how Lisp actually operates. It's time to fill this [gap][2].</p>
<p>Lisp has a number of built in data types. Integers and strings, for example, aren't much different from what you're used to. The meaning of <em>71</em> or &quot;<em>hello</em>&quot; is roughly the same in Lisp as in C++ or Java. What is of more interest to us are <em>symbols</em>, <em>lists</em>, and <em>functions</em>. I will spend the rest of this section describing these data types as well as how a Lisp environment compiles and executes the source code you type into it (this is called <em>evaluation</em> in Lisp lingo). Getting through this section in one piece is important for understanding true potential of Lisp's metaprogramming, the unity of code and data, and the notion of domain specific languages. Don't think of this section as a chore though, I'll try to make it fun and accessible. Hopefully you can pick up a few interesting ideas on the way. Ok. Let's start with Lisp's symbols.</p>
<p>A symbol in Lisp is roughly equivalent to C++ or Java's notion of an identifier. It's a name you can use to access a variable (like <em>currentTime</em>, <em>arrayCount</em>, <em>n</em>, etc.) The difference is that a symbol in Lisp is a lot more liberal than its mainstream identifier alternative. In C++ or Java you're limited to alphanumeric characters and an underscore. In Lisp, you are not. For example <code>+</code> is a valid symbol. So is <code>-</code>, <code>=</code>, <code>hello-world</code>, <code>hello+world</code>, <code>*</code>, etc. (you can find the exact definition of valid Lisp symbols online). You can assign to these symbols any data-type you like. Let's ignore Lisp syntax and use pseudo-code for now. Assume that a function <code>set</code> assigns some value to a symbol (like <code>=</code> does in Java or C++). The following are all valid examples:</p>
<pre><code class="language-cpp">set(test, 5)            // symbol 'test' will equal an integer 5
set(=, 5)               // symbol '=' will equal an integer 5
set(test, &quot;hello&quot;)      // symbol 'test' will equal a string &quot;hello&quot;
set(test, =)            // at this point symbol '=' is equal to 5
                        // therefore symbol 'test' will equal to 5
set(*, &quot;hello&quot;)         // symbol '*' will equal a string &quot;hello&quot;
</code></pre>
<p>At this point something must smell wrong. If we can assign strings and integers to symbols like <code>*</code>, how does Lisp do multiplication? After all, <code>*</code> means multiply, right? The answer is pretty simple. Functions in Lisp aren't special. There is a data-type, function, just like integer and string, that you assign to symbols. A multiplication function is built into Lisp and is assigned to a symbol <code>*</code>. You can reassign a different value to <code>*</code> and you'd lose the multiplication function. Or you can store the value of the function in some other variable. Again, using pseudo-code:</p>
<pre><code class="language-cpp">*(3, 4)                 // multiplies 3 by 4, resulting in 12
set(temp, *)            // symbol '*' is equal to the multiply function
                        // so temp will equal to the multiply function
set(*, 3)               // sets symbol '*' to equal to 3
*(3, 4)                 // error, symbol '*' no longer equals to a function
                        // it's equal to 3
temp(3, 4)              // temp equals to a multiply function
                        // so Lisp multiplies 3 by 4 resulting in 12
set(*, temp)            // symbol '*' equals multiply function again
*(3, 4)                 // multiplies 3 by 4, resulting in 12
</code></pre>
<p>You can even do wacky stuff like reassigning plus to minus:</p>
<pre><code class="language-cpp">set(+, -)               // the value of '-' is a built in minus function
                        // so now symbol '+' equals to a minus function
+(5, 4)                 // since symbol '+' is equal to the minus function
                        // this results in 1
</code></pre>
<p>I've used functions quite liberally in these examples but I didn't describe them yet. A function in Lisp is just a data-type like an integer, a string, or a symbol. A function doesn't have a notion of a name like in Java or C++. Instead, it stands on its own. Effectively it is a pointer to a block of code along with some information (like a number of parameters it accepts). You only give the function a name by assigning it to a symbol, just like you assign an integer or a string. You can create a function by using a built in function for creating functions, assigned to a symbol 'fn'. Using pseudo-code:</p>
<pre><code class="language-cpp">fn [a]
{
    return *(a, 2);
}
</code></pre>
<p>This returns a function that takes a single parameter named 'a' and doubles it. Note that the function has no name but you can assign it to a symbol:</p>
<pre><code class="language-lisp">set(times-two, fn [a] { return *(a, 2); })
</code></pre>
<p>We can now call this function:</p>
<pre><code class="language-cpp">times-two(5)             // returns 10
</code></pre>
<p>Now that we went over symbols and functions, what about lists? Well, you already know a lot about them. Lists are simply pieces of XML written in s-expression form. A list is specified by parentheses and contains Lisp data-types (including other lists) separated by a space. For example (this is real Lisp, note that we use semicolons for comments now):</p>
<pre><code class="language-lisp">()                      ; an empty list
(1)                     ; a list with a single element, 1
(1 &quot;test&quot;)              ; a list with two elements
                        ; an integer 1 and a string &quot;test&quot;
(test &quot;hello&quot;)          ; a list with two elements
                        ; a symbol test and a string &quot;hello&quot;
(test (1 2) &quot;hello&quot;)    ; a list with three elements, a symbol test
                        ; a list of two integers 1 and 2
                        ; and a string &quot;hello&quot;
</code></pre>
<p>When a Lisp system encounters lists in the source code it acts exactly like Ant does when it encounters XML - it attempts to execute them. In fact, Lisp source code is only specified using lists, just like Ant source code is only specified using XML. Lisp executes lists in the following manner. The first element of the list is treated as the name of a function. The rest of the elements are treated as functions parameters. If one of the parameters is another list it is executed using the same principles and the result is passed as a parameter to the original function. That's it. We can write real code now:</p>
<pre><code class="language-lisp">(* 3 4)                 ; equivalent to pseudo-code *(3, 4).
                        ; Symbol '*' is a function
                        ; 3 and 4 are its parameters.
                        ; Returns 12.
(times-two 5)           ; returns 10
(3 4)                   ; error: 3 is not a function
(times-two)              ; error, times-two expects one parameter
(times-two 3 4)          ; error, times-two expects one parameter
(set + -)               ; sets symbol '+' to be equal to whatever symbol '-'
                        ; equals to, which is a minus function
(+ 5 4)                 ; returns 1 since symbol '+' is now equal
                        ; to the minus function
(* 3 (* 2 2))           ; multiplies 3 by the second parameter
                        ; (which is a function call that returns 4).
                        ; Returns 12.
</code></pre>
<p>Note that so far every list we've specified was treated by a Lisp system as code. But how can we treat a list as data? Again, imagine an Ant task that accepts XML as one of its parameters. In Lisp we do this using a quote operator ' like so:</p>
<pre><code class="language-lisp">(set test '(1 2))       ; test is equal to a list of two integers, 1 and 2
(set test (1 2))        ; error, 1 is not a function
(set test '(* 3 4))     ; sets test to a list of three elements,
                        ; a symbol *, an integer 3, and an integer 4
</code></pre>
<p>We can use a built in function head to return the first element of the list, and a built in function tail to return the rest of the list's elements:</p>
<pre><code class="language-lisp">(head '(* 3 4))         ; returns a symbol '*'
(tail '(* 3 4))         ; returns a list (3 4)
(head (tail '( * 3 4))) ; (tail '(* 3 4)) returns a list (3 4)
                        ; and (head '(3 4)) returns 3.
(head test)             ; test was set to a list in previous example
                        ; returns a symbol '*'
</code></pre>
<p>You can think of built in Lisp functions as you think of Ant tasks. The difference is that we don't have to extend Lisp in another language (although we can), we can extend it in Lisp itself as we did with the times-two example. Lisp comes with a very compact set of built in functions - the necessary minimum. The rest of the language is implemented as a standard library in Lisp itself.</p>
<h1 id="lisp-macros">Lisp Macros</h1>
<p>So far we've looked at metaprogramming in terms of a simple templating engine similar to JSP. We've done code generation using simple string manipulations. This is generally how most code generation tools go about doing this task. But we can do much better. To get on the right track, let's start off with a question. How would we write a tool that automatically generates Ant build scripts by looking at source files in the directory structure?</p>
<p>We could take the easy way out and generate Ant XML by manipulating strings. Of course a much more abstract, expressive and extensible way is to work with XML processing libraries to generate XML nodes directly in memory. The nodes can then be serialized to strings automatically. Furthermore, our tool would be able to analyze and transform existing Ant build scripts by loading them and dealing with the XML nodes directly. We would abstract ourselves from strings and deal with higher level concepts which let us get the job done faster and easier.</p>
<p>Of course we could write Ant tasks that allow dealing with XML transformations and write our generation tool in Ant itself. Or we could just use Lisp. As we saw earlier, a list is a built in Lisp data structure and Lisp has a number of facilities for processing lists quickly and effectively (head and tail being the simplest ones). Additionally Lisp has no semantic constraints - you can have your code (and data) have any structure you want.</p>
<p>Metaprogramming in Lisp is done using a construct called a &quot;macro&quot;. Let's try to develop a set of macros that transform data like, say, a to-do list (surprised?), into a language for dealing with to-do lists.</p>
<p>Let's recall our to-do list example. The XML looks like this:</p>
<pre><code class="language-xml">&lt;todo name=&quot;housework&quot;&gt;
    &lt;item priority=&quot;high&quot;&gt;Clean the house.&lt;/item&gt;
    &lt;item priority=&quot;medium&quot;&gt;Wash the dishes.&lt;/item&gt;
    &lt;item priority=&quot;medium&quot;&gt;Buy more soap.&lt;/item&gt;
&lt;/todo&gt;
</code></pre>
<p>The corresponding s-expression version looks like this:</p>
<pre><code class="language-lisp">(todo &quot;housework&quot;
    (item (priority high) &quot;Clean the house.&quot;)
    (item (priority medium) &quot;Wash the dishes.&quot;)
    (item (priority medium) &quot;Buy more soap.&quot;))
</code></pre>
<p>Suppose we're writing a to-do manager application. We keep our to-do items serialized in a set of files and when the program starts up we want to read them and display them to the user. How would we do this with XML and some other language (say, Java)? We'd parse our XML files with the to-do lists using some XML parser, write the code that walks the XML tree and converts it to a Java data structure (because frankly, processing DOM in Java is a pain in the neck), and then use this data structure to display the data. Now, how would we do the same thing in Lisp?</p>
<p>If we were to adopt the same approach we'd parse the files using Lisp libraries responsible for parsing XML. The XML would then be presented to us as a Lisp list (an s-expression) and we'd walk the list and present relevant data to the user. Of course if we used Lisp it would make sense to persist the data as s-expressions directly as there's no reason to do an XML conversion. We wouldn't need special parsing libraries since data persisted as a set of s-expressions is valid Lisp and we could use Lisp compiler to parse it and store it in memory as a Lisp list. Note that Lisp compiler (much like .NET compiler) is available to a Lisp program at runtime.</p>
<p>But we can do better. Instead of writing code to walk the s-expression that stores our data we could write a macro that allows us to treat data as code! How do macros work? Pretty simple, really. Recall that a Lisp function is called like this:</p>
<pre><code class="language-lisp">(function-name arg1 arg2 arg3)
</code></pre>
<p>Where each argument is a valid Lisp expression that's evaluated and passed to the function. For example if we replace <em>arg1</em> above with <code>(+ 4 5)</code>, it will be evaluated and <code>9</code> would be passed to the function. A macro works the same way as a function, except its arguments are not evaluated.</p>
<pre><code class="language-lisp">(macro-name (+ 4 5))
</code></pre>
<p>In this case, <code>(+ 4 5)</code> is not evaluated and is passed to the macro as a list. The macro is then free to do what it likes with it, including evaluating it. The return value of a macro is a Lisp list that's treated as code. The original place with the macro is replaced with this code. For example, we could define a macro plus that takes two arguments and puts in the code that adds them.</p>
<p>What does it have to do with metaprogramming and our to-do list problem? Well, for one, macros are little bits of code that generate code using a list abstraction. Also, we could create macros named <em>to-do</em> and <em>item</em> that replace our data with whatever code we like, for instance code that displays the item to the user.</p>
<p>What benefits does this approach offer? We don't have to walk the list. The compiler will do it for us and will invoke appropriate macros. All we need to do is create the macros that convert our data to appropriate code!</p>
<p>For example, a macro similar to our <em>triple C</em> macro we showed earlier looks like this:</p>
<pre><code class="language-lisp">(defmacro triple (x)
    '(+ ~x ~x ~x))
</code></pre>
<p>The quote prevents evaluation while the tilde allows it. Now every time triple is encountered in lisp code:</p>
<pre><code class="language-lisp">(triple 4)
</code></pre>
<p>it is replaced with the following code:</p>
<pre><code class="language-lisp">(+ 4 4 4)
</code></pre>
<p>We can create macros for our to-do list items that will get called by lisp compiler and will transform the to-do list into code. Now our to-do list will be treated as code and will be executed. Suppose all we want to do is print it to standard output for the user to read:</p>
<pre><code class="language-lisp">(defmacro item (priority note)
    '(block
         (print stdout tab &quot;Priority: &quot;
             ~(head (tail priority)) endl)
         (print stdout tab &quot;Note: &quot; ~note endl endl)))
</code></pre>
<p>We've just created a very small and limited language for managing to-do lists embedded in Lisp. Such languages are very specific to a particular problem domain and are often referred to as domain specific languages or <em>DSLs</em>.</p>
<h1 id="domain-specific-languages">Domain Specific Languages</h1>
<p>In this article we've already encountered two domain specific languages: Ant (specific to dealing with project builds) and our unnamed mini-language for dealing with to-do lists. The difference is that Ant was written from scratch using XML, an XML parser, and Java while our language is embedded into Lisp and is easily created within a couple of minutes.</p>
<p>We've already discussed the benefits of DSLs, mainly why Ant is using XML, not Java source code. Lisp lets us create as many DSLs as we need for our problem. We can create domain specific languages for creating web applications, writing massively multiplayer games, doing fixed income trading, solving the protein folding problem, dealing with transactions, etc. We can layer these languages on top of each other and create a language for writing web-based trading applications by taking advantage of our web application language and bond trading language. Every day we'd reap the benefits of this approach, much like we reap the benefits of Ant.</p>
<p>Using DSLs to solve problems results in much more compact, maintainable, flexible programs. In a way we create them in Java by creating classes that help us solve the problem. The difference is that Lisp allows us to take this abstraction to the next level: we're not limited by Java's parser. Think of writing build scripts in Java itself using some supporting library. Compare it to using Ant. Now apply this same comparison to every single problem you've ever worked on and you'll begin to glimpse a small share of the benefits offered by Lisp.</p>
<h1 id="whats-next">What's next?</h1>
<p>Learning Lisp is an uphill battle. Even though in Computer Science terms Lisp is an ancient language, few people to date figured out how to teach it well enough to make it accessible. Despite great efforts by many Lisp advocates, learning Lisp today is still hard. The good news is that this won't remain the case forever since the amount of Lisp-related resources is rapidly increasing. Time is on Lisp's side.</p>
<p>Lisp is a way to escape mediocrity and to get ahead of the pack. Learning Lisp means you can get a better job today, because you can impress any reasonably intelligent interviewer with fresh insight into most aspects of software engineering. It also means you're likely to get fired tomorrow because everyone is tired of you constantly mentioning how much better the company could be doing if only its software was written in Lisp. Is it worth the effort? Everyone who has ever learned Lisp says yes. The choice, of course, remains yours.</p>
<h1 id="comments">Comments?</h1>
<p>Whew. That's enough. I've been writing this article, on and off, for months. If you find it interesting, have any questions, comments, or suggestions, please drop a note at <a href="mailto:coffeemug@gmail.com">coffeemug@gmail.com</a>. I'll be glad to hear your feedback.</p>
<p>[1]: I have never met James, nor does he know about my existence. The story is entirely fictional and is based on a few postings about Ant's history I found on the internet.</p>
<p>[2]: Lisp has many different dialects (the most popular of which are Common Lisp and Scheme). Each dialect deals with intricate details differently yet shares the same set of basic principles. Since the goal of this article is to give you an understanding of Lisp's principles I will use Blaise for examples (which at the time of this writing is vaporware). With some minor modifications these examples can be translated to other Lisp dialects.</p>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[Amazon Web Services]]></title>
        <id>https://faded.auspicious.space/post/amazon-web-services/</id>
        <link href="https://faded.auspicious.space/post/amazon-web-services/">
        </link>
        <updated>2020-05-31T12:57:27.000Z</updated>
        <summary type="html"><![CDATA[<blockquote>
<p><a href="https://adayinthelifeof.nl/2020/05/20/aws.html">Amazon Web Services</a></p>
</blockquote>
]]></summary>
        <content type="html"><![CDATA[<blockquote>
<p><a href="https://adayinthelifeof.nl/2020/05/20/aws.html">Amazon Web Services</a></p>
</blockquote>
<!-- more -->
<p>More often than not, I’m using Amazon Web Services (AWS) as my “cloud”. Not only for my own projects, but almost all customers I’m working for use Amazon for hosting their applications. So over time you build up a lot of experience on AWS service: you know how to (correctly) setup VPC’s, know when to you ECS, EC2 or lambda to host code and even services like S3, SNS and SQS pose no challenges anymore.</p>
<p>But there are a lot of AWS services available. And I do mean: a LOT. Currently, there are 163 (!) different services that are available from the Amazon Dashboard, each with their own way of working, difficulties, catches and best practises.</p>
<h1 id="discovering-aws">Discovering AWS</h1>
<p>You might realise that it’s probably near impossible to dive into each service and completely understand how they work and most likely, you don’t really need to know the exact ins and outs. But, having a basic understanding on each service can be a major benefit as a developer, architect or administrator. It makes it easier to see if there is an already existing solution for your problem at hand.</p>
<p>So, I dove into each and every service to figure out what it exactly was for and how it works in the basics. I tried to experiment with as many components as possible (time and money permitting, I didn’t want to spend 15.000$ on AWS Data Exchange). I tried to capture what the service does in a single one-liner to give you a global overview.</p>
<p>I think most of them are correct enough but if you have any suggestions or corrections, please tell me!</p>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[软件设计，那些你不知道的事]]></title>
        <id>https://faded.auspicious.space/post/software-design-things-you-dont-know/</id>
        <link href="https://faded.auspicious.space/post/software-design-things-you-dont-know/">
        </link>
        <updated>2020-05-28T02:58:34.000Z</updated>
        <summary type="html"><![CDATA[<blockquote>
<p><a href="https://juejin.im/post/5bd7f3fa5188251135281da2">软件设计，那些你不知道的事</a></p>
</blockquote>
]]></summary>
        <content type="html"><![CDATA[<blockquote>
<p><a href="https://juejin.im/post/5bd7f3fa5188251135281da2">软件设计，那些你不知道的事</a></p>
</blockquote>
<!-- more -->
<p>代码质量和产出是衡量一个程序员是否优秀最直接的标准。如何提高代码质量和产出？这就要从软件重构和 review 入手。市面上有很多关于重构和 review 的书籍，但是看完之后，代码能力并不能立竿见影显著提升，只能帮助我们解决表面的 bug 和规范点，无法帮助我们发现更深层次的设计问题。</p>
<p>从设计角度来考虑 review，识别代码坏味道可以可以有效减少技术债务。技术债务是指有意或无意的做出错误的或非最优的设计决策所引发的债务。债务越积越多，最后只能重新彻底重构项目才能解决问题，这也叫做技术破产。如何解决技术债务问题，就要从根源上明确引起技术债务的重要的原因——设计坏味和重构认识不足。</p>
<h1 id="首先要明确软件设计原则">首先要明确软件设计原则</h1>
<ul>
<li><strong>抽象原则：</strong> 通过精简和概括来简化实体：精简指的是删除不必要的细节，概括是找出并定义重要的通用特征。</li>
<li><strong>非循环依赖原则：</strong> 包之间的关系不可形成循环。</li>
<li><strong>不自我重复原则：</strong> 在详细设计中，设计实体和代码和重复可能表现为类型名重复和实现重复。</li>
<li><strong>封装原则：</strong> 通过隐藏抽象的实现细节和隐藏变化等方法实现关注点分离和信息隐藏。</li>
<li><strong>信息隐藏原则：</strong> 找出棘手或可能变化的设计决策，并创建合适的模块或类型来对其他模块或类型隐藏这些决策。</li>
<li><strong>保持简单原则：</strong> 简洁是软件系统设计的重要目标，应避免引入不必要的复杂性。</li>
<li><strong>里氏替换原则：</strong> 所有的子类型都必须至少提供超类型承诺的行为且对每个超类型的引用都可替换成子类型实例。</li>
<li><strong>层次接口原则：</strong> 使用分类、概括、替换、排序等方法以层次方式组织对抽象。</li>
<li><strong>模块化原则：</strong> 通过集中和分解等手法创建高内聚、低耦合的抽象。</li>
<li><strong>开闭原则：</strong> 类型应对扩展开放，对修改关闭。具体是模块应该能够在不修改代码情况下支持新需求。</li>
<li><strong>单一职责原则：</strong> 绝不应有多个导致类需要修改的原因，如修改一个成员可能影响类的其他不相关职责，导致类难以维护。</li>
<li><strong>变化封装原则：</strong> 倡导一种信息隐藏方式，建议将可能发生变化的概念封装起来。很多设计模式都体现了这种设计原则，如策略模式、桥梁模式、观察者模式。</li>
</ul>
<h1 id="我们从设计的角度来看代码时要遵循六要素">我们从设计的角度来看代码时，要遵循六要素</h1>
<ul>
<li><strong>可理解性：</strong> 代码理解起来的难易程度。</li>
<li><strong>可修改性：</strong> 在修改既有功能时，不会导致连锁反应。</li>
<li><strong>可扩展性：</strong> 支持新功能，不会导致连锁反应。</li>
<li><strong>可重用性：</strong> 可以在代码的其他地方引用其一块代码。</li>
<li><strong>可测试性：</strong> 项目要能够支持单元测试。</li>
<li><strong>可靠性：</strong> 在正确地实现了功能的同时，也能够考虑各种异常情况如何容错。</li>
</ul>
<h1 id="了解完设计原则和六要素后我们再来看设计坏味">了解完设计原则和六要素后，我们再来看设计坏味</h1>
<ul>
<li>抽象型</li>
<li>封装型</li>
<li>层次结构</li>
<li>模块化型</li>
</ul>
<p>本文中每种坏味我们只选其中一例做具体说明。</p>
<h2 id="抽象型坏味">抽象型坏味</h2>
<p>抽象原则倡导通过精简和概括来简化实体：精简指的是删除不必要的细节，而概括指的是找出并定义通过的重要特征。交通标志是用于交流的抽象示例，而数字符号和编程语言是用于解决问题的抽象示例。</p>
<ul>
<li>缺失抽象</li>
<li>命令式抽象</li>
<li>多方面的抽象</li>
<li>不必要的抽象</li>
<li>未用的抽象</li>
<li>重复的抽象</li>
</ul>
<h3 id="缺失抽象">缺失抽象</h3>
<p>使用一系列数据或者编码字符串，而不创建类或者接口时会产生这种坏味。</p>
<h4 id="概念">概念</h4>
<p>应用抽象原则的一种实现手法是创建概念边界清晰，身份唯一的实体。由于没有创建抽象来表示实体，而是使用基本数据类型或编码字符串等原始数据来表示它，这违反了抽象原则，将这种坏味称为缺失抽象（Missing Abstraction）。不必要的抽象也违反了模块化原则。</p>
<h4 id="潜在原因">潜在原因</h4>
<ul>
<li>未做重复的设计分析</li>
<li>未重构</li>
<li>错误的将重点放在细微的性能改善上</li>
</ul>
<h4 id="示例">示例</h4>
<p>在 JDK1.0 中方法 <code>printStackTrace()</code> 以字符串的方式将栈跟踪打印到标准错误流。</p>
<p>在需要以编程方式访问栈跟踪元素的客户程序中，必须要编程代码来获取数据，如行号等，由于客户程度依赖这种字符串格式，JDK 设计人员只能在后续版本中兼容这种格式了。</p>
<pre><code class="language-java">public class Throwable {
    public void printStackTrace() {
        printStackTrace(System.err);
    }
}
</code></pre>
<h4 id="重构建议">重构建议</h4>
<p>从 JDK1.4 起对 JAVA 的 API 进行了改进，<code>StackTraceElement</code> 类就是原来设计中缺失的对象。</p>
<pre><code class="language-java">public class Throwable {
    public void printStackTrace() {
        printStackTrace(System.err);
    }
    public StackTraceElement[] getStackTrace() {
        return getOurStackTrace().clone();
    }
}

/**
 * @since 1.4
 * @author Josh Bloch
 */
public final class StackTraceElement implements java.io.Serializable {
    // Normally initialized by VM (public constructor added in 1.5)
    private String declaringClass;
    private String methodName;
    private String fileName;
    private int lineNumber;
}
</code></pre>
<ul>
<li>别名
<ol>
<li>基本类型偏执：使用基本类型对日期、金额进行编码，而不创建类时，将引发这种坏味。</li>
<li>数据泥团：在很多地方同事使用一系列数据项，而不创建类时，将引发这种坏味。</li>
</ol>
</li>
<li>现实考虑
<ol>
<li>避免过度设计:有时候，实体只是数据元素，没有任何相关联的行为。这种情况下使用类或者接口来表示它们可能导致过度设计。</li>
</ol>
</li>
</ul>
<h2 id="封装型坏味">封装型坏味</h2>
<p>封装原则倡导通过隐藏抽象的实现细节和隐藏变化等手法实现关注的分离和信息隐藏。比如开车必须知道发动机原理吗？</p>
<ul>
<li>不充分的封装</li>
<li>泄露的封装</li>
<li>缺失封装</li>
<li>未利用封装</li>
</ul>
<h3 id="不充分的封装">不充分的封装</h3>
<p>对于抽象的一个或多个成员，声明的访问权限超过了实际需求时，将导致这种坏味。例如，将字段声明为公有的类就存在「不充分封装」坏味。</p>
<h4 id="概念-2">概念</h4>
<p>封装的原则是将接口和实现分离，以便能独立修改。这种关注点分离，让客户程序只依赖抽象的接口，而对它们隐藏具体实现。修改实现不影响客户程序。对抽象的内部隐藏的不充分称为不充分的封装（Deficient Encapsulation）。</p>
<h4 id="潜在原因-2">潜在原因</h4>
<ul>
<li>为方便测试</li>
<li>在面向对象中采用过程思维</li>
<li>快速交付</li>
</ul>
<h4 id="示例-2">示例</h4>
<ul>
<li>来看看 <code>java.lang.System</code>，<code>in</code>、<code>out</code>、<code>err</code> 都被声明成 <code>final</code>，但可以通过<code>java.lang.System</code> 的 <code>setIn</code>、<code>setOut</code>、<code>setErr</code> 分别赋值。任何代码都能很方便的使用它们，比如 <code>System.out.println()</code>；</li>
<li><code>PrintStream</code> 是 Java 1.0 就有的，只支持 8 位的 ASCII 值，Java1.1 出的 <code>PrintWriter</code> 支持 Unicode，然而就是因为应用程序都能直接使用 <code>PrintStream</code> 来访问 <code>PrintStream</code> 的方法，根本不能摒弃 <code>PrintStream</code> 类。</li>
</ul>
<pre><code class="language-java">public final static InputStream in = null;
public final static PrintStream out = null;
public final static PrintStream err = null;

public static void setIn(InputStream in) {
    checkIO();
    setIn0(in);
}
</code></pre>
<h4 id="重构建议-2">重构建议</h4>
<p>Java 1.6 引入了 <code>java.io.Console</code> 类，他提供了用于访问基于字符的控制台的方法。<code>reader()</code>、<code>writer()</code> 来获取 <code>Console</code> 相关的 <code>Writer</code> 和 <code>Reader</code> 对象。</p>
<ul>
<li>别名
<ol>
<li>可隐藏的公有属性、方法</li>
<li>未封装的类</li>
<li>包含未参数化方法的类</li>
</ol>
</li>
<li>现实考虑
<ol>
<li>嵌套或匿名类中过于宽松的访问性</li>
<li>性能考虑：比如前面说的 <code>java.lang.System</code></li>
</ol>
</li>
</ul>
<h2 id="模块化坏味">模块化坏味</h2>
<p>模块化原则倡导利用集中和分解等手法创建高内聚、低耦合的抽象。</p>
<ul>
<li>拆散的模块化</li>
<li>不充分的模块化</li>
<li>循环依赖式模块化</li>
<li>轮毂式模块化</li>
</ul>
<h3 id="拆散的模块化">拆散的模块化</h3>
<p>应集中放在一个抽象中的数据和方法分散在多个抽象中时，将导致这种坏味。表现为类被用作数据容器没有任何方法、类的方法更多的被其他类的成员调用。</p>
<h4 id="概念-3">概念</h4>
<p>一种重要的模块化实现手法是「将相关的数据和方法集中在一起」。如果抽象中只包含数据成员，而操作这些数据成员的方法位于其他抽象中，它就违反了这种实现手法，存在「拆散的模块化」坏味。称为拆散的模块化（Broken Modularization）。</p>
<h4 id="潜在原因-3">潜在原因</h4>
<ul>
<li>以过程思维使用面向对象语言</li>
<li>不熟悉既有设计</li>
</ul>
<h4 id="重构建议-3">重构建议</h4>
<p>对于包含大量数据类的过程型设计，可采用重构手法“将过程型设计转换为对象”。</p>
<ul>
<li>别名
<ol>
<li>被动地存储数据的类</li>
<li>数据类</li>
<li>数据记录</li>
<li>记录类</li>
<li>数据容器</li>
<li>错位的操作</li>
<li>依恋情结</li>
<li>错位的控制</li>
</ol>
</li>
<li>现实考虑
<ol>
<li>自动生成的代码</li>
<li>数据传输对象</li>
</ol>
</li>
</ul>
<h2 id="层次型坏味">层次型坏味</h2>
<p>层次结构原则倡导采用分类、归并、替换和排序等手法以层次方式组织抽象。比如地球上的 870 万种生物。</p>
<ul>
<li>缺失层次结构</li>
<li>不必要层次结构</li>
<li>为归并的层次结构</li>
<li>过宽的层次结构</li>
<li>凭空想象的层次结构</li>
<li>过深的层次结构</li>
<li>叛逆型层次结构</li>
<li>支离破碎的层次结构</li>
<li>多路径层次结构</li>
<li>循环层次结构</li>
</ul>
<h3 id="缺失的层次结构">缺失的层次结构</h3>
<p>代码片段使用条件逻辑来显式管理行为变化，而原本可以创建一个层次目录，并使用它来封装这些变化，会产生这种坏味。</p>
<h4 id="概念-4">概念</h4>
<ul>
<li>基于类型码的 <code>switch</code> 语句（或串接的 <code>if-else</code> 语句）是最著名的设计坏味之一。</li>
<li>使用类型码来处理行为变化表明没有进行有意义的分类，导致设计中缺少相应的层次结构。称为缺失层次结构（Missing Hierarchy）。</li>
</ul>
<h4 id="潜在原因-4">潜在原因</h4>
<ul>
<li>错误的采用过于简单的设计</li>
<li>过程型设计思维</li>
<li>忽视了继承也是一种设计手法</li>
</ul>
<h4 id="示例-3">示例</h4>
<p>串接的 <code>if else</code> 语句显示的检查类型 <code>AbstractButton</code>，<code>JToolBar</code> 和 <code>JTextCompont</code>并在各种条件下调用方法 <code>getMargin()</code>，这种造成的情况是将来可能在代码中的其他地方也会出现。</p>
<pre><code class="language-java">public Inserts getBorderInserts(Component c, Inserts inserts) {
    if(c instanceof AbstractButton) {
        margin = ((AbstractButton)c).getMargin();
    } else if(c instanceof JToolBar) {
        margin = ((JToolBar)c).getMargin();
    } else if(c instanceof JTextComponent) {
        margin = ((JTextComponent)c).getMargin();
    }
}
</code></pre>
<h4 id="重构建议-4">重构建议</h4>
<ol>
<li>如果条件检查中的多个实现调用方法相同，可引入相关的接口来抽象共同的协议。</li>
<li>如果代码中包含可转换为类的条件语句，可采用重构手法“提取层次结构”来创建一个类层次结构，其中每个类都表示条件检查中的一种情形。</li>
</ol>
<ul>
<li>别名
<ol>
<li>标记类</li>
<li>继承缺位</li>
<li>紧缩的类型层次结构</li>
<li>内嵌功能</li>
</ol>
</li>
<li>现实考虑
<ol>
<li>与外部交互</li>
</ol>
</li>
</ul>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[你可能会错过的 CSS 伪选择器]]></title>
        <id>https://faded.auspicious.space/post/css-pseudo-classes-you-might-have-missed/</id>
        <link href="https://faded.auspicious.space/post/css-pseudo-classes-you-might-have-missed/">
        </link>
        <updated>2020-05-27T03:53:58.000Z</updated>
        <summary type="html"><![CDATA[<blockquote>
<p><a href="https://juejin.im/post/5eaea84f51882558dc24bc94">[译]你可能会错过的 CSS 伪选择器</a></p>
</blockquote>
]]></summary>
        <content type="html"><![CDATA[<blockquote>
<p><a href="https://juejin.im/post/5eaea84f51882558dc24bc94">[译]你可能会错过的 CSS 伪选择器</a></p>
</blockquote>
<!-- more -->
<blockquote>
<p>（伪）选择器可以为文档中不一定具体存在的结构指定样式，或者为某些元素、文档的标记模式、甚至是文档本身的状态所指示的幻像类指定样式。 —— CSS 权威指南：Eric Meyer、Estelle Weyl</p>
</blockquote>
<p>这篇文章鼓励构造 UI 时使用更多纯 CSS 和更少的 JS。熟悉所有的 CSS 是实现这个目标的一种方法 —— 另一种是实施最佳实践和尽可能的减少代码。</p>
<h1 id="first-line-选择首行文本"><code>::first-line</code> | 选择首行文本</h1>
<p>这个伪元素选择器选择换行之前文本的首行。</p>
<pre><code class="language-css">p:first-line {
    color: lightcoral;
}
</code></pre>
<h1 id="first-letter-选择首字母"><code>::first-letter</code> | 选择首字母</h1>
<p>这个伪元素选择器应用于元素中文本的首字母。</p>
<pre><code class="language-css">.innerDiv p:first-letter {
    color: lightcoral;
    font-size: 40px
}
</code></pre>
<h1 id="selection-选择高亮被选中的区域"><code>::selection</code> | 选择高亮（被选中）的区域</h1>
<p>应用于任何被用户选中的高亮区域。</p>
<p>通过 <code>::selection</code> 伪元素选择器，我们可以将样式应用于高亮区域。</p>
<pre><code class="language-css">div::selection {
    background: yellow;
}
</code></pre>
<h1 id="root-根元素"><code>:root</code> | 根元素</h1>
<p><code>:root</code> 伪类选中文档的根元素。在 HTML 中，为 HTML 元素。在 RSS 中，则为 RSS 元素.</p>
<p>这个伪类选择器应用于根元素，多用于存储全局 CSS 自定义属性。</p>
<h1 id="empty-仅当元素为空时触发"><code>:empty</code> | 仅当元素为空时触发</h1>
<p>这个伪类选择器将选中没有任何子项的元素。该元素必须为空。如果一个元素没有空格、可见的内容、后代元素，则为空元素。</p>
<pre><code class="language-css">div:empty {
    border: 2px solid orange;
}
</code></pre>
<pre><code class="language-html">&lt;div&gt;&lt;/div&gt;
&lt;div&gt;&lt;/div&gt;
&lt;div&gt;
&lt;/div&gt;
</code></pre>
<p>这个规则将应用于空的 <code>div</code> 元素。这个规则将应用于第一个和第二个 <code>div</code>，因为他们是真为空，而第三个 <code>div</code> 包含空格。</p>
<h1 id="only-child-选择仅有的子元素"><code>:only-child</code> | 选择仅有的子元素</h1>
<p>匹配父元素中没有任何兄弟元素的子元素。</p>
<pre><code class="language-css">.innerDiv p:only-child {
    color: orangered;
}
</code></pre>
<h1 id="first-of-type-选择第一个指定类型的子元素"><code>:first-of-type</code> | 选择第一个指定类型的子元素</h1>
<pre><code class="language-css">.innerDiv p:first-of-type {
    color: orangered;
}
</code></pre>
<p>这将应用于 <code>.innerDiv</code> 下的第一个 <code>p</code> 元素。</p>
<pre><code class="language-html">&lt;div class=&quot;innerDiv&quot;&gt;
    &lt;div&gt;Div1&lt;/div&gt;
    &lt;p&gt;These are the necessary steps&lt;/p&gt;
    &lt;p&gt;hiya&lt;/p&gt;
    
    &lt;p&gt;
        Do &lt;em&gt;not&lt;/em&gt; push the brake at the same time as the accelerator.
    &lt;/p&gt;
    &lt;div&gt;Div2&lt;/div&gt;
&lt;/div&gt;
</code></pre>
<p>这个 <code>p</code>（“These are the necessary step”）将被选中。</p>
<h1 id="last-of-type-选择最后一个指定类型的子元素"><code>:last-of-type</code> | 选择最后一个指定类型的子元素</h1>
<p>像 <code>:first-of-type</code> 一样，但是会应用于最后一个同类型的子元素。</p>
<pre><code class="language-css">.innerDiv p:last-of-type {
    color: orangered;
}
</code></pre>
<p>这将应用于 <code>innerDiv</code> 下的最后一个 <code>p</code> 段落元素。</p>
<pre><code class="language-html">&lt;div class=&quot;innerDiv&quot;&gt;
    &lt;p&gt;These are the necessary steps&lt;/p&gt;
    &lt;p&gt;hiya&lt;/p&gt;
    &lt;div&gt;Div1&lt;/div&gt;
    &lt;p&gt;
        Do the same.
    &lt;/p&gt;
    &lt;div&gt;Div2&lt;/div&gt;
&lt;/div&gt;
</code></pre>
<p>因此，这个 <code>p</code> 元素（“Do the same”）将被选中。</p>
<h1 id="nth-of-type-选择特定类型的子元素"><code>:nth-of-type()</code> | 选择特定类型的子元素</h1>
<p>这个选择器将从指定的父元素的孩子列表中选择某种类型的子元素。</p>
<pre><code class="language-css">.innerDiv p:nth-of-type(1) {
    color: orangered;
}
</code></pre>
<h1 id="nth-last-of-type-选择列表末尾中指定类型的子元素"><code>:nth-last-of-type()</code> | 选择列表末尾中指定类型的子元素</h1>
<p>这将选择最后一个指定类型的子元素。</p>
<pre><code class="language-css">.innerDiv p:nth-last-of-type() {
    color: orangered;
}
</code></pre>
<p>这将选择 <code>innerDiv</code> 列表元素中包含的最后一个段落类型子元素。</p>
<pre><code class="language-html">&lt;div class=&quot;innerDiv&quot;&gt;
    &lt;p&gt;These are the necessary steps&lt;/p&gt;
    &lt;p&gt;hiya&lt;/p&gt;
    &lt;div&gt;Div1&lt;/div&gt;
    &lt;p&gt;
        Do the same.
    &lt;/p&gt;
    &lt;div&gt;Div2&lt;/div&gt;
&lt;/div&gt;
</code></pre>
<p><code>innerDiv</code> 中最后一个段落子元素 <code>p</code>（“Do the same”）将会被选中。</p>
<h1 id="link-选择一个未访问过的超链接"><code>:link</code> | 选择一个未访问过的超链接</h1>
<p>这个选择器应用于未被访问过的链接。常用于带有 <code>href</code> 属性的 <code>a</code> 锚元素。</p>
<pre><code class="language-css">a:link {
    color: orangered;
}
</code></pre>
<pre><code class="language-html">&lt;a href=&quot;/login&quot;&gt;Login&lt;a&gt;
</code></pre>
<p>这将选中未被点击过带有 <code>href</code> 的指定界面的 <code>a</code> 锚点元素，选中的元素中的文字将会显示为橙色。</p>
<h1 id="checked-选择一个选中的复选框"><code>:checked</code> | 选择一个选中的复选框</h1>
<p>这个应用于已经被选中的复选框。</p>
<pre><code class="language-css">input:checked {
    border: 2px solid lightcoral;
}
</code></pre>
<p>这个规则应用到所有被选中的复选框。</p>
<h1 id="valid-选择一个通过验证的元素"><code>:valid</code> | 选择一个通过验证的元素</h1>
<p>这主要用于可视化表单元素，以让用户判断是否验证通过。验证通过时，默认元素带有 <code>valid</code> 属性。</p>
<pre><code class="language-css">input:valid {
    boder-color: lightsalmon;
}
</code></pre>
<h1 id="invalid-选择一个未通过验证的元素"><code>:invalid</code> | 选择一个未通过验证的元素</h1>
<p>像 <code>:valid</code> 一样，但是会应用到未通过验证的元素。</p>
<pre><code class="language-css">input[type=&quot;text&quot;]:invalid {
    border-color: red;
}
</code></pre>
<h1 id="lang-选择指定语言的元素"><code>:lang()</code> | 选择指定语言的元素</h1>
<p>应用于指定了语言的元素。</p>
<p>可以通过以下两种方式使用：</p>
<pre><code class="language-css">p:lang(fr) {
    background: yellow;
}
</code></pre>
<p>或者</p>
<pre><code class="language-css">p[lang|=&quot;fr&quot;] {
    background: yellow;
}
</code></pre>
<pre><code class="language-html">&lt;p lang=&quot;fr&quot;&gt;Paragraph 1&lt;/p&gt;
</code></pre>
<h1 id="not-对于选择取反这是一个运算符"><code>:not()</code> | 对于选择取反（这是一个运算符）</h1>
<p>否定伪类选择器选中相反的。</p>
<p>让我们看一个示例：</p>
<pre><code class="language-css">.innerDiv :not(p) {
    color: lightcoral;
}
</code></pre>
<pre><code class="language-html">&lt;div class=&quot;innerDiv&quot;&gt;
    &lt;p&gt;Paragraph 1&lt;/p&gt;
    &lt;p&gt;Paragraph 2&lt;/p&gt;
    &lt;div&gt;Div 1&lt;/div&gt;
    &lt;p&gt;Paragraph 3&lt;/p&gt;
    &lt;div&gt;Div 2&lt;/div&gt;
&lt;/div&gt;
</code></pre>
<p><code>Div 1</code> 和 <code>Div 2</code> 会被选中，因为他们不是 <code>p</code> 元素。</p>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[通过 JavaScript 获取内网 IP 和外网 IP 的简单方法]]></title>
        <id>https://faded.auspicious.space/post/a-simple-way-to-access-both- intranet-and-extranet-ip-through-javascript/</id>
        <link href="https://faded.auspicious.space/post/a-simple-way-to-access-both- intranet-and-extranet-ip-through-javascript/">
        </link>
        <updated>2020-05-27T03:45:37.000Z</updated>
        <summary type="html"><![CDATA[<blockquote>
<p><a href="https://www.cnblogs.com/wjyz/p/10638584.html">通过js获取内网ip和外网ip的简单方法 ...</a></p>
</blockquote>
]]></summary>
        <content type="html"><![CDATA[<blockquote>
<p><a href="https://www.cnblogs.com/wjyz/p/10638584.html">通过js获取内网ip和外网ip的简单方法 ...</a></p>
</blockquote>
<!-- more -->
<h1 id="获取内网-ip">获取内网 IP</h1>
<pre><code class="language-javascript">function getIP(callback) {
    let recode = {};
    let RTCPeerConnection = window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection;
    // 如果不存在则使用一个iframe绕过
    if (!RTCPeerConnection) {
        // 因为这里用到了iframe，所以在调用这个方法的script上必须有一个iframe标签
        // &lt;iframe id=&quot;iframe&quot; sandbox=&quot;allow-same-origin&quot; style=&quot;display:none;&quot;&gt;&lt;/iframe&gt;
        let win = iframe.contentWindow;
        RTCPeerConnection = win.RTCPeerConnection || win.mozRTCPeerConnection || win.webkitRTCPeerConnection;
    }

    //创建实例，生成连接
    let pc = new RTCPeerConnection();

    // 匹配字符串中符合ip地址的字段
    function handleCandidate(candidate) {
        let ip_regexp = /([0-9]{1,3}(\.[0-9]{1,3}){3}|([a-f0-9]{1,4}((:[a-f0-9]{1,4}){7}|:+[a-f0-9]{1,4}){6}))/;
        let ip_isMatch = candidate.match(ip_regexp)[1];
        if (!recode[ip_isMatch]) {
            callback(ip_isMatch);
            recode[ip_isMatch] = true;
        }
    }

    //监听icecandidate事件
    pc.onicecandidate = (ice) =&gt; {
        if (ice.candidate) {
            handleCandidate(ice.candidate.candidate);
        }
    };
    //建立一个伪数据的通道
    pc.createDataChannel('');
    pc.createOffer((res) =&gt; {
        pc.setLocalDescription(res);
    }, () =&gt; { });

    //延迟，让一切都能完成
    setTimeout(() =&gt; {
        let lines = pc.localDescription.sdp.split('\n');
        lines.forEach(item =&gt; {
            if (item.indexOf('a=candidate:') === 0) {
                handleCandidate(item);
            }
        })
    }, 1000);
}
</code></pre>
<p>调用该函数：</p>
<pre><code class="language-javascript">getIP(function (ip) {
    console.log(ip);
})

// 192.168.1.191
// 2001::2841:aa90:2843:1983:e4d1:a9b8
</code></pre>
<h2 id="获取公网-ip">获取公网 IP</h2>
<pre><code class="language-html">&lt;!--引入接口文件--&gt;
&lt;script type=&quot;text/javascript&quot; src=&quot;http://pv.sohu.com/cityjson?ie=utf-8&quot;&gt;&lt;/script&gt;

&lt;!--返回结果为 var returnCitySN = {&quot;cip&quot;: &quot;27.46.86.71&quot;, &quot;cid&quot;: &quot;440000&quot;, &quot;cname&quot;: &quot;广东省&quot;};

在下面的js中，通过调用returnCitySN.cip就可以获取 外网的ip--&gt;
</code></pre>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[一篇文章掌握 14 种 UML 图]]></title>
        <id>https://faded.auspicious.space/post/mastering-14-uml-diagrams-in-a-single-article/</id>
        <link href="https://faded.auspicious.space/post/mastering-14-uml-diagrams-in-a-single-article/">
        </link>
        <updated>2020-05-27T02:57:41.000Z</updated>
        <summary type="html"><![CDATA[<blockquote>
<p><a href="https://mp.weixin.qq.com/s?__biz=MzIxMjE5MTE1Nw==&amp;mid=2653202874&amp;idx=3&amp;sn=81aa87a3a8faa1c353d78ec31b30ed3d&amp;chksm=8c99db60bbee5276a5bff014e8800b0e4513754d309a3540d4a5b1f0b59e9af05418b0c21a61&amp;mpshare=1&amp;scene=23&amp;srcid=&amp;sharer_sharetime=1588477918993&amp;sharer_shareid=d8e58ea207a9c340f9ebfddc69dc6b8e#rd">UML科普文，一篇文章掌握14种UML图</a></p>
</blockquote>
]]></summary>
        <content type="html"><![CDATA[<blockquote>
<p><a href="https://mp.weixin.qq.com/s?__biz=MzIxMjE5MTE1Nw==&amp;mid=2653202874&amp;idx=3&amp;sn=81aa87a3a8faa1c353d78ec31b30ed3d&amp;chksm=8c99db60bbee5276a5bff014e8800b0e4513754d309a3540d4a5b1f0b59e9af05418b0c21a61&amp;mpshare=1&amp;scene=23&amp;srcid=&amp;sharer_sharetime=1588477918993&amp;sharer_shareid=d8e58ea207a9c340f9ebfddc69dc6b8e#rd">UML科普文，一篇文章掌握14种UML图</a></p>
</blockquote>
<!-- more -->
<h1 id="什么是-uml">什么是 UML？</h1>
<p>UML 是 Unified Model Language 的缩写，中文是统一建模语言，是由一整套图表组成的标准化建模语言。</p>
<h1 id="为什么要用-uml">为什么要用 UML？</h1>
<p>通过使用 UML 使得在软件开发之前， 对整个软件设计有更好的可读性，可理解性，从而降低开发风险。同时，也能方便各个开发人员之间的交流。</p>
<p>UML 提供了极富表达能力的建模语言，可以让软件开发过程中的不同人员分别得到自己感兴趣的信息。</p>
<p>Page-Jones 在《Fundamental Object-Oriented Design in UML》 一书中总结了 UML 的主要目的，如下：</p>
<ol>
<li>为用户提供现成的、有表现力的可视化建模语言，以便他们开发和交换有意义的模型。</li>
<li>为核心概念提供可扩展性（Extensibility）和特殊化（Specialization）机制。</li>
<li>独立于特定的编程语言和开发过程。</li>
<li>为了解建模语言提供一个正式的基础。</li>
<li>鼓励面向对象工具市场的发展。</li>
<li>支持更高层次的开发概念，如协作，框架，模式和组件。</li>
<li>整合最佳的工作方法（Best Practices）。</li>
</ol>
<h1 id="uml-图有哪些">UML 图有哪些？</h1>
<ul>
<li>UML 图分为结构图和行为图。</li>
<li>结构图分为类图、轮廓图、组件图、组合结构图、对象图、部署图、包图。</li>
<li>行为图又分活动图、用例图、状态机图和交互图。</li>
<li>交互图又分为序列图、时序图、通讯图、交互概览图。</li>
</ul>
<figure data-type="image" tabindex="1"><img src="https://faded.auspicious.space/post-images/1590548880541.webp" alt="" loading="lazy"></figure>
<h1 id="uml-图概览">UML 图概览</h1>
<table>
<thead>
<tr>
<th>UML 类型</th>
<th>目的</th>
<th>版本</th>
</tr>
</thead>
<tbody>
<tr>
<td>类图</td>
<td>描述了系统中对象的类型以及他们之间存在的各种静态关系。</td>
<td>UML 1.x</td>
</tr>
<tr>
<td>组件图</td>
<td>描绘了系统中组件提供的、需要的接口、端口等，以及它们之间的关系。</td>
<td>UML 1.x，UML 2.0 重新定义了</td>
</tr>
<tr>
<td>对象图</td>
<td>对象图是类图的一个实例，是系统在某个时间点的详细状态的快照。</td>
<td>UML 1.x</td>
</tr>
<tr>
<td>轮廓图</td>
<td>轮廓图提供了一种通用的扩展机制，用于为特定域和平台定制 UML 模型。</td>
<td>UML 2.0</td>
</tr>
<tr>
<td>组合结构图</td>
<td>描述了一个“组合结构”的内部结构，以及它们之间的关系。</td>
<td>UML 2.0</td>
</tr>
<tr>
<td>部署图</td>
<td>描绘了系统在包层面上的结构设计。</td>
<td>UML 1.x</td>
</tr>
<tr>
<td>包图</td>
<td>描绘了系统在包层面上的结构设计。</td>
<td>UML 2.0</td>
</tr>
<tr>
<td></td>
<td></td>
<td></td>
</tr>
<tr>
<td>用例图</td>
<td>指由参与者、用例、边界以及它们之间的关系构成的用于描述系统功能的视图。</td>
<td>UML 1.x</td>
</tr>
<tr>
<td>活动图</td>
<td>描述了具体业务用例的实现流程。</td>
<td>UML 1.x</td>
</tr>
<tr>
<td>状态机图</td>
<td>描述了对象在它的整个生命周期里，响应不同事件时，执行相关事件的顺序。</td>
<td>UML 1.x</td>
</tr>
<tr>
<td>序列图</td>
<td>描述了在用例的特定场景中，对象如何与其他对象交互。</td>
<td>UML 1.x</td>
</tr>
<tr>
<td>时序图</td>
<td>时序图被用来显示随时间变化，一个或多个元素的值或状态的更改。</td>
<td>UML 2.0</td>
</tr>
<tr>
<td>交互概览图</td>
<td>交互概览图与活动图类似，但是它的节点是交互图。</td>
<td>UML 2.0</td>
</tr>
<tr>
<td>通讯图</td>
<td>描述了收发消息的对象的组织关系，强调对象之间的合作关系而不是时间顺序。</td>
<td>UML 1.x 叫协作图，UML 2.0 改名了</td>
</tr>
</tbody>
</table>
<h1 id="什么是类图">什么是类图？</h1>
<h2 id="概念">概念</h2>
<p>类图是一切面向对象方法的核心建模工具。类图描述了系统中对象的类型以及它们之间存在的各种静态关系。</p>
<h2 id="目的">目的</h2>
<p>用来表示类、接口以及它们之间的静态结构和关系。</p>
<h2 id="关系">关系</h2>
<p>在类图中，常见的有以下几种关系。</p>
<h3 id="泛化generalization">泛化（Generalization）</h3>
<p>【泛化关系】是一种继承关系，表示子类继承父类的所有特征和行为。<br>
【箭头指向】带三角箭头的实线，箭头指向父类。<br>
<img src="https://faded.auspicious.space/post-images/1590550145305.webp" alt="" loading="lazy"></p>
<h3 id="实现realization">实现（Realization）</h3>
<p>【实现关系】是一种类与接口的关系，表示类是接口所有特征和行为的实现。<br>
【箭头指向】带三角箭头的虚线，箭头指向接口。<br>
<img src="https://faded.auspicious.space/post-images/1590550168640.webp" alt="" loading="lazy"></p>
<h3 id="关联association">关联（Association）</h3>
<p>【关联关系】是一种拥有关系，它使得一个类知道另一个类的属性和方法。<br>
【代码体现】成员变量<br>
【箭头指向】带普通箭头的实线，指向被拥有者。双向的关联可以有两个箭头，或者没有箭头。单向的关联有一个箭头。<br>
<img src="https://faded.auspicious.space/post-images/1590550191227.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>自己买的车，想什么时候开就开。但是车是车，人是人，没有整体与部分的关系。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h3 id="聚合aggregation">聚合（Aggregation）</h3>
<p>【聚合关系】是一种整体与部分的关系。且部分可以离开整体而单独存在。聚合关系是关联关系的一种，是强的关联关系；关联和聚合在语法上无法区分，必须考察具体的逻辑关系。<br>
【代码体现】成员变量<br>
【箭头指向】带空心菱形的实线，空心菱形指向整体。<br>
<img src="https://faded.auspicious.space/post-images/1590550313146.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>电脑有键盘才能输入信息，电脑是整体，键盘是部分，键盘也可以离开电脑，单纯的拿去敲。所以是聚合。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h3 id="组合composition">组合（Composition）</h3>
<p>【组合关系】是一种整体与部分的关系。但部分不能离开整体而单独存在，组合关系是关联关系的一种，是比聚合关系还要强的关系。<br>
【代码体现】成员变量<br>
【箭头指向】带实心菱形和普通箭头的实线，实心菱形指向整体。<br>
<img src="https://faded.auspicious.space/post-images/1590550378083.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>鸟是整体，翅膀是部分。鸟死了，翅膀也就不能飞了。所以是组合。我们再看一下，下面的一组经典的聚合组合关系的例子。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<figure data-type="image" tabindex="2"><img src="https://faded.auspicious.space/post-images/1590550399447.webp" alt="" loading="lazy"></figure>
<table>
<thead>
<tr>
<th>一个公司拥有多个部门，公司和部门之间是组合关系，公司破产了，部门就不复存在了。部门和员工是聚合关系，部门被裁掉，员工就换下家了。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h3 id="依赖dependency">依赖（Dependency）</h3>
<p>【依赖关系】是一种使用关系，即一个类的实现需要另一个类的协助。<br>
【箭头指向】带普通箭头的虚线，普通箭头指向被使用者。<br>
<img src="https://faded.auspicious.space/post-images/1590550431782.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>老司机只管开车，车是谁的不重要，给什么车开什么车。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="什么是组件图">什么是组件图？</h1>
<p>【概念】描绘了系统中组件提供的、需要的接口、端口等，以及它们之间的关系。<br>
【目的】用来展示各个组件之间的依赖关系。<br>
<img src="https://faded.auspicious.space/post-images/1590550471545.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>订单系统组件依赖于客户资源库和库存系统组件。中间的虚线箭头表示依赖关系。另外两个符号，表示组件连接器，一个提供接口，一个需要接口。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="什么是部署图">什么是部署图？</h1>
<p>【概念】描述了系统内部的软件如何分布在不同的节点上。<br>
【目的】用来表示软件和硬件的映射关系。<br>
<img src="https://faded.auspicious.space/post-images/1590550499680.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>图中简单的表示，不同机器上面部署的不同软件。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="什么是对象图">什么是对象图？</h1>
<p>【概念】对象图是类图的一个实例，是系统在某个时间点的详细状态的快照。<br>
【目的】用来表示两个或者多个对象之间在某一时刻之间的关系。<br>
<img src="https://faded.auspicious.space/post-images/1590550525802.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>图中就是描述的，某时间点 bat 这个公司有一个研发部，一个销售部，两个部门只有一个人 iisheng。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="什么是包图">什么是包图？</h1>
<p>【概念】描绘了系统在包层面上的结构设计。<br>
【目的】用来表示包和包之间的依赖关系。<br>
<img src="https://faded.auspicious.space/post-images/1590550565122.webp" alt="" loading="lazy"></p>
<ul>
<li>《Use》关系表示使用依赖，Web Shopping 依赖 Payment</li>
<li>《Merge》关系表示合并，Web Shopping 合并了 Shopping Cart 就拥有了 Shopping Cart 的功能</li>
<li>《Access》关系表示私有引入，比如代码中的指定包名类名</li>
<li>《Import》关系表示公共引入，比如 Java 中的 import 之后，就可以直接使用 import 包中的类了。</li>
</ul>
<h1 id="什么是组合结构图">什么是组合结构图？</h1>
<p>【概念】描述了一个“组合结构”的内部结构，以及他们之间的关系。这个“组合结构”可以是系统的一部分，或者一个整体。<br>
【目的】用来表示系统中逻辑上的“组合结构”。<br>
<img src="https://faded.auspicious.space/post-images/1590550644923.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>图中描述了 Car 是由车轴连接着的两个前面轮子、两个后面轮子，和引擎组合的。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="什么是轮廓图">什么是轮廓图？</h1>
<p>【概念】轮廓图提供了一种通用的扩展机制，用于为特定域和平台定制 UML 模型。<br>
【目的】用于在特定领域中构建 UML 模型。<br>
<img src="https://faded.auspicious.space/post-images/1590550693950.png" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>图中我们定义了一个简易的 EJB 的概要图。Bean 是从 Component 扩展来的。Entity Bean 和 Session Bean 继承了 Bean。EJB 拥有 Remote 和 Home 接口，和 JAR 包。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="什么是用例图">什么是用例图？</h1>
<p>【概念】用例图是指由参与者、用例，边界以及它们之间的关系构成的用于描述系统功能的视图。<br>
【目的】用来描述整个系统的功能。<br>
<img src="https://faded.auspicious.space/post-images/1590550808766.webp" alt="" loading="lazy"></p>
<p>用例图中包含以下三种关系：</p>
<ul>
<li>包含关系使用符号《include》，想要查看订单列表，前提是需要先登录。</li>
<li>扩展关系使用符号《extend》，基于查询订单列表的功能，可以增加一个导出数据的功能</li>
<li>泛化关系，子用例继承父用例所有结构、行为和关系。</li>
</ul>
<h1 id="什么是活动图">什么是活动图？</h1>
<p>【概念】描述了具体业务用例的实现流程。<br>
【目的】用来表示用例实现的工作流程。<br>
<img src="https://faded.auspicious.space/post-images/1590550849436.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>图中简单描述了，从开始到登录到查看订单列表，或者登录失败直接结束。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="什么是状态机图">什么是状态机图？</h1>
<p>【概念】状态机图对一个单独对象的行为建模，指明对象在它的整个生命周期里，响应不同事件时，执行相关事件的顺序。<br>
【目的】用来表示指定对象，在整个生命周期，响应不同事件的不同状态。<br>
<img src="https://faded.auspicious.space/post-images/1590550897707.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>图中描述了，门在其生命周期内所经历的状态。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="什么是序列图">什么是序列图？</h1>
<p>【概念】序列图根据时间序列展示对象如何进行协作。它展示了在用例的特定场景中，对象如何与其他对象交互。<br>
【目的】通过描述对象之间发送消息的时间顺序显示多个对象之间的动态协作。<br>
<img src="https://faded.auspicious.space/post-images/1590550935611.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>图中展示的是支付宝条码支付场景的序列图。其中，loop 是循环，alt 是选择，序列图的其他关系这里就不介绍了。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="什么是通讯图">什么是通讯图？</h1>
<p>【概念】描述了收发消息的对象的组织关系，强调对象之间的合作关系而不是时间顺序。<br>
【目的】用来显示不同对象的关系。<br>
<img src="https://faded.auspicious.space/post-images/1590550970253.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>图中展示了一个线上书店的通讯图，方框和小人表示生命线，不同生命线之间可以传递消息，消息前面的数字可以表达序列顺序。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="什么是交互概览图">什么是交互概览图？</h1>
<p>【概念】交互概览图与活动图类似，但是它的节点是交互图。<br>
【目的】提供了控制流的概述。<br>
<img src="https://faded.auspicious.space/post-images/1590551002003.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>图中表示一个调度系统的交互概览图，跟活动图很像。其中 sd 的框代表具体的交互流程，ref 框代表使用交互。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="什么是时序图">什么是时序图？</h1>
<p>【概念】时序图被用来显示随时间变化，一个或多个元素的值或状态的更改。也显示时控事件之间的交互和管理它们的时间和期限约束。<br>
【目的】用来表示元素状态或者值随时间的变化而变化的视图。<br>
<img src="https://faded.auspicious.space/post-images/1590551036333.webp" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th>图中展示了老年痴呆病人随着时间的变化病情的变化。</th>
</tr>
</thead>
<tbody></tbody>
</table>
<h1 id="总结">总结</h1>
<p>学习 UML，我们没必要纠结比如像聚合关系是带箭头还是不带箭头，这样的问题。更重要的是 UML 图所给我们带来的画图思想，让我们画 UML 图或者其他图能让其他人更好的理解我们的设计思想。</p>
<p>参考文献：<br>
[1]:《Learning UML 2.0》<br>
[2]: <a href="https://www.uml-diagrams.org/">https://www.uml-diagrams.org/</a><br>
[3]: <a href="https://www.visual-paradigm.com/guide/">https://www.visual-paradigm.com/guide/</a><br>
[4]: <a href="https://sparxsystems.com/resources/tutorials/">https://sparxsystems.com/resources/tutorials/</a></p>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[关于数据库使用和开发的一些建议]]></title>
        <id>https://faded.auspicious.space/post/things-i-wished-more-developers-knew-about-databases/</id>
        <link href="https://faded.auspicious.space/post/things-i-wished-more-developers-knew-about-databases/">
        </link>
        <updated>2020-05-26T05:55:47.000Z</updated>
        <summary type="html"><![CDATA[<blockquote>
<p><a href="https://medium.com/@rakyll/things-i-wished-more-developers-knew-about-databases-2d0178464f78">https://medium.com/@rakyll/things-i-wished-more-developers-knew-about-databases-2d0178464f78</a></p>
</blockquote>
]]></summary>
        <content type="html"><![CDATA[<blockquote>
<p><a href="https://medium.com/@rakyll/things-i-wished-more-developers-knew-about-databases-2d0178464f78">https://medium.com/@rakyll/things-i-wished-more-developers-knew-about-databases-2d0178464f78</a></p>
</blockquote>
<!-- more -->
<ul>
<li>You are lucky if 99.999% of the time network is not a problem.</li>
<li>ACID has many meanings.</li>
<li>Each database has different consistency and isolation capabilities.</li>
<li>Optimistic locking is an option when you can't hold a lock.</li>
<li>There are anomalies other than dirty reads and data loss.</li>
<li>My database and I don't always agree on ordering.</li>
<li>Application-level sharding can live outside the application.</li>
<li>AUTOINCREMENT'ing can be harmful.</li>
<li>Stale data can be useful and lock-free.</li>
<li>Clock skews happen between any clock sources.</li>
<li>Latency has many meanings.</li>
<li>Evaluate performance requirements per transaction.</li>
<li>Nested transactions can be harmful.</li>
<li>Transactions shouldn't maintain application state.</li>
<li>Query planners can tell a lot about databases.</li>
<li>Online migrations are complex but possible.</li>
<li>Significant database growth introduces unpredictability.</li>
</ul>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[A letter to myself as a fresh software engineer]]></title>
        <id>https://faded.auspicious.space/post/a-letter-to-myself-as-a-fresh-software-engineer/</id>
        <link href="https://faded.auspicious.space/post/a-letter-to-myself-as-a-fresh-software-engineer/">
        </link>
        <updated>2020-05-26T03:50:17.000Z</updated>
        <summary type="html"><![CDATA[<blockquote>
<p><a href="https://www.florio.dev/20200328-letter-to-myself/">A letter to myself as a fresh software engineer</a></p>
</blockquote>
]]></summary>
        <content type="html"><![CDATA[<blockquote>
<p><a href="https://www.florio.dev/20200328-letter-to-myself/">A letter to myself as a fresh software engineer</a></p>
</blockquote>
<!-- more -->
<p>Dear Self,</p>
<p>You just graduated and you are ready to start your career in the IT field. I cannot spoiler anything, but I assure you it will be an interesting ride. I'm writing you this letter because I want to give you some advice that will help you be a better professional. Nothing you won't learn by yourself in the next few years, but it is something that I wish someone had told me when I started my career. They are not ordered by any means and are <strong>all equally important</strong>.</p>
<h1 id="run-a-marathon-not-a-sprint">Run a marathon, not a sprint.</h1>
<p>The road to becoming a good software engineer is a long one. <strong>Don't rush on stuff</strong>, and don't give up just because you are not getting an easy and fast win. Take your time to learn and become good in the topics you are interested in. Remember that this is a marathon, not a sprint.</p>
<h1 id="be-humble-not-stupid">Be humble, not stupid.</h1>
<p>It is good — sorry, it is <strong>fundamental</strong> — to be humble. There is always something to learn from others, even when you are an experienced professional. But this doesn't mean that everyone is better than you. You have to <strong>respect yourself and your skills</strong>. When you don't respect yourself you become stupid, not humble.</p>
<h1 id="compare-with-yourself-not-others">Compare with yourself, not others.</h1>
<p>There is no point in comparing yourself with others. There will always be someone better than you in your job. And there will always be someone better than the one that is better than you. And there will… ok, you got the point. <strong>Just do your best</strong>. If you think someone is a better engineer than you are, learn from him/her. Keep doing your best, and eventually, you will be a reference for someone else.</p>
<h1 id="respect-people-not-titles">Respect people, not titles.</h1>
<p>During your career, you will work with exceptional professional. Most important, you will meet exceptional human beings. <strong>Respect people for who they are</strong>, not for the title they have. If foo is &quot;Principal Senior Lead Engineering Chief Architect&quot; doesn't mean that he deserves more respect than bar that is a junior software developer.</p>
<h1 id="choose-the-challenge-not-comfort">Choose the challenge, not comfort.</h1>
<p>The road will be full of crossroads. There may be multiple choices, but everything boils down to a choice between your comfort zone, or go outside your comfort zone. There may be a moment in your life — hopefully after decades of work — when you will feel the need to cool down a bit because you will be satisfied with what you achieved. Until that moment, try to go out of your comfort zone. It will make you a better professional and you will feel more satisfied with your career. Remember that the <strong>best things often happen outside the comfort zone</strong>.</p>
<h1 id="jump-on-the-whiteboard-not-on-the-keyboard">Jump on the whiteboard, not on the keyboard.</h1>
<p>When you have to design a new feature or a new system, don't jump on the keyboard to start coding. The &quot;muscle&quot; you have to train and use as an engineer is your brain, not your fingers. <strong>Always think before act</strong>. For this reason, jump on the whiteboard instead of the keyboard, and start thinking of what you should implement. Better if you have a sparring partner to challenge your thoughts. Oh, when I say &quot;the whiteboard&quot; I mean &quot;every object that can help you think&quot;, be it pen and paper, a notebook application, <a href="https://app.diagrams.net/">draw.io</a>, etc.</p>
<h1 id="deliver-value-not-code">Deliver value, not code.</h1>
<p>Please don't be affected by the <a href="https://en.wikipedia.org/wiki/Not_invented_here">NIH syndrome</a>. There is no point in reinventing the wheel. <strong>Avoid wasting time in something that is already out there</strong>. If you can achieve your goal simply glueing together some tools, just do it. What you should deliver as a software engineer is value to your business, not lines of code.</p>
<h1 id="choose-life-not-work">Choose life, not work.</h1>
<p>In the IT field, it is easy to focus too much on work. After all, for most of us, it is not just a job, it is passion. Remember that <strong>work is important, but life is more</strong>. Live a meaningful and rich life. Play sports, read books, find hobbies, travel and see the beautiful world we are living in. Hangout with friends, find a partner for your life and give to your partner all the love, attention, and support that you can. You'll be surprised how much having a rich life will improve you as a professional.</p>
<p>That's all I can tell you right now. I still have a lot to learn.</p>
<p>One last thing: <strong>enjoy the ride</strong>! 🚀</p>
<p>With love,</p>
<p>(a more experienced) You.</p>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[SQLite vs MySQL vs PostgreSQL: A Comparison Of Relational Database Management Systems]]></title>
        <id>https://faded.auspicious.space/post/sqlite-vs-mysql-vs-postgresql-a-comparison-of-relational-database-management-systems/</id>
        <link href="https://faded.auspicious.space/post/sqlite-vs-mysql-vs-postgresql-a-comparison-of-relational-database-management-systems/">
        </link>
        <updated>2020-05-22T09:34:32.000Z</updated>
        <summary type="html"><![CDATA[<blockquote>
<p><a href="https://www.digitalocean.com/community/tutorials/sqlite-vs-mysql-vs-postgresql-a-comparison-of-relational-database-management-systems">SQLite vs MySQL vs PostgreSQL: A Comparison Of Relational Database Management Systems</a></p>
</blockquote>
]]></summary>
        <content type="html"><![CDATA[<blockquote>
<p><a href="https://www.digitalocean.com/community/tutorials/sqlite-vs-mysql-vs-postgresql-a-comparison-of-relational-database-management-systems">SQLite vs MySQL vs PostgreSQL: A Comparison Of Relational Database Management Systems</a></p>
</blockquote>
<!-- more -->
<h1 id="introduction">Introduction</h1>
<p>The <em>relational data model</em>, which organizes data in tables of rows and columns, predominates in database management tools. Today there are other data models, including <a href="https://en.wikipedia.org/wiki/NoSQL">NoSQL</a> and <a href="https://en.wikipedia.org/wiki/NewSQL">NewSQL</a>, but relational database management systems (RDBMSs) <a href="https://db-engines.com/en/ranking_categories">remain dominant</a> for storing and managing data worldwide.</p>
<p>This article compares and contrasts three of the most widely implemented open-source RDBMSs: <a href="https://www.sqlite.org/index.html">SQLite</a>, <a href="https://www.mysql.com/">MySQL</a>, and <a href="https://www.postgresql.org/">PostgreSQL</a>. Specifically, it will explore the data types that each RDBMS uses, their advantages and disadvantages, and situations where they are best optimized.</p>
<h1 id="a-bit-about-database-management-systems">A Bit About Database Management Systems</h1>
<p><em>Databases</em> are logically modelled clusters of information, or <em>data</em>. A <em>database management system</em> (DBMS), on the other hand, is a computer program that interacts with a database. A DBMS allows you to control access to a database, write data, run queries, and perform any other tasks related to database management. Although database management systems are often referred to as &quot;databases&quot;, the two terms are not interchangeable. A database can be any collection of data, not just one stored on a computer, while a DBMS is the software that allows you to interact with a database.</p>
<p>All database management systems have an underlying model that structures how data is stored and accessed. A relational database management system is a DBMS that employs the relational data model. In this model, data are organized into tables, which in the context of RDBMSs are more formally referred to as <em>relations</em>. A relation is a set of <em>tuples</em>, or rows in a table, with each tuple sharing a set of <em>attributes</em>, or columns:<br>
<img src="https://faded.auspicious.space/post-images/1590140364388.png" alt="" loading="lazy"></p>
<p>Most relational databases use <em>structured query language</em> (SQL) to manage and query data. However, many RDBMSs use their own particular dialect of SQL, which may have certain limitations or extensions. These extensions typically include extra features that allow users to perform more complex operations than they otherwise could with standard SQL.</p>
<p><strong>Note:</strong> The term &quot;standard SQL&quot; comes up several times throughout this guide. SQL standards are jointly maintained by the <a href="https://www.ansi.org/">American National Standards Institute (ANSI)</a>, the <a href="https://www.iso.org/home.html">International Organization for Standardization (ISO)</a>, and the <a href="https://www.iec.ch/">International Electrotechnical Commission (IEC)</a>. Whenever this article mentions &quot;standard SQL&quot; or &quot;the SQL standard&quot;, it's referring to the current version of the SQL standard published by these bodies.</p>
<p>It should be noted that the full SQL standard is large and complex: full core SQL:2011 compliance requires 179 features. Because of this, most RDBMSs don't support the entire standard, although some do come closer to full compliance than others.</p>
<p>Each column is assigned a <em>data type</em> which dictates what kind of entries are allowed in that column. Different RDBMSs implement different data types, which aren't always directly interchangeable. Some common data types include dates, strings, integers, and Booleans.</p>
<p>Numeric data types can either be <em>signed</em>, meaning they can represent both positive and negative numbers, or <em>unsigned</em>, which means they can only represent positive numbers. For example, MySQL's <code>tinyint</code> data type can hold 8 bits of data, which equates to 256 possible values. The signed range of this data type is from -128 to 127, while the unsigned range is from 0 to 255.</p>
<p>Sometimes, a database administrator will impose a <em>constraint</em> on a table to limit what values can be entered into it. A constraint typically applies to one particular column, but some constraints can also apply to an entire table. Here are some constraints that are commonly used in SQL:</p>
<ul>
<li><code>UNIQUE</code>: Applying this constraint to a column ensures that no two entries in that column are identical.</li>
<li><code>NOT NULL</code>: This constraint ensures that a column doesn't have any NULL entries.</li>
<li><code>PRIMARY KEY</code>: A combination of <code>UNIQUE</code> and <code>NOT NULL</code>, the <code>PRIMARY KEY</code> constraint ensures that no entry in the column is <code>NULL</code> and that every entry is distinct.</li>
<li><code>FOREIGN KEY</code>: A <code>FOREIGN KEY</code> is a column in one table that refers to the <code>PRIMARY KEY</code> of another table. This constraint is used to link two tables together: entries to the <code>FOREIGN KEY</code> column must already exist in the parent <code>PRIMARY KEY</code> column for the write process to succeed.</li>
<li><code>CHECK</code>: This constraint limits the range of values that can be entered into a column. For example, if your application is intended only for residents of Alaska, you could add a <code>CHECK</code> constraint on a ZIP code column to only allow entries between 99501 and 99950.</li>
<li><code>DEFAULT</code>: This provides a default value for a given column. Unless another value is specified, SQLite enters the default value automatically.</li>
<li><code>INDEX</code>: Used to help retrieve data from a table more quickly, this constraint is similar to an index in a textbook: instead of having to review every entry in a table, a query only has to review entries from the indexed column to find the desired results.</li>
</ul>
<p>If you'd like to learn more about database management systems, check out our article on <a href="https://www.digitalocean.com/community/articles/understanding-sql-and-nosql-databases-and-different-database-models">Understanding SQL and NoSQL Databases and Different Database Models</a>.</p>
<p>Now that we've covered relational database management systems generally, let's move onto the first of the three open-source relational databases this article will cover: SQLite.</p>
<h1 id="sqlite">SQLite</h1>
<p>SQLite is a self-contained, file-based, and fully open-source RDBMS known for its portability, reliability, and strong performance even in low-memory environments. Its transactions are <a href="https://en.wikipedia.org/wiki/ACID_(computer_science)">ACID-compliant</a>, even in cases where the system crashes or undergoes a power outage.</p>
<p>The <a href="https://www.sqlite.org/serverless.html">SQLite project's website</a> describes it as a &quot;serverless&quot; database. Most relational database engines are implemented as a server process in which programs communicate with the host server through an interprocess communication that relays requests. With SQLite, though, any process that accesses the database reads from and writes to the database disk file directly. This simplifies SQLite's setup process, since it eliminates any need to configure a server process. Likewise, there's no configuration necessary for programs that will use the SQLite database: all they need is access to the disk.</p>
<p>SQLite is free and open-source software, and no special license is required to use it. However, the project does offer several extensions — each for a one-time fee — that help with compression and encryption. Additionally, the project offers various commercial support packages, each for an annual fee.</p>
<h2 id="sqlites-supported-data-types">SQLite's Supported Data Types</h2>
<p>SQLite allows a variety of data types, organized into the following storage classes:</p>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>null</code></td>
<td>Includes any <code>NULL</code> values.</td>
</tr>
<tr>
<td><code>integer</code></td>
<td>Signed integers, stored in 1, 2, 3, 4, 6, or 8 bytes depending on the magnitude of the value.</td>
</tr>
<tr>
<td><code>real</code></td>
<td>Real numbers, or floating point values, stored as 8-byte floating point numbers.</td>
</tr>
<tr>
<td><code>text</code></td>
<td>Text strings stored using the database encoding, which can either be UTF-8, UTF-16BE or UTF-16LE.</td>
</tr>
<tr>
<td><code>blob</code></td>
<td>Any blob of data, with every blob stored exactly as it was input.</td>
</tr>
</tbody>
</table>
<p>In the context of SQLite, the terms &quot;storage class&quot; and &quot;data type&quot; are considered interchangeable. If you'd like to learn more about SQLite's data types and SQLite type affinity, check out SQLite's <a href="http://www.sqlite.org/datatype3.html">official documentation</a> on the subject.</p>
<h2 id="advantages-of-sqlite">Advantages of SQLite</h2>
<ul>
<li><strong>Small footprint:</strong> As its name implies, the SQLite library is very lightweight. Although the space it uses varies depending on the system where it's installed, it can take up less than 600KiB of space. Additionally, it's fully self-contained, meaning there aren't any external dependencies you have to install on your system for SQLite to work.</li>
<li><strong>User-friendly:</strong> SQLite is sometimes described as a &quot;zero-configuration&quot; database that's ready for use out of the box. SQLite doesn't run as a server process, which means that it never needs to be stopped, started, or restarted and doesn't come with any configuration files that need to be managed. These features help to streamline the path from installing SQLite to integrating it with an application.</li>
<li><strong>Portable:</strong> Unlike other database management systems, which typically store data as a large batch of separate files, an entire SQLite database is stored in a single file. This file can be located anywhere in a directory hierarchy, and can be shared via removable media or file transfer protocol.</li>
</ul>
<h2 id="disadvantages-of-sqlite">Disadvantages of SQLite</h2>
<ul>
<li><strong>Limited concurrency:</strong> Although multiple processes can access and query an SQLite database at the same time, only one process can make changes to the database at any given time. This means SQLite supports greater concurrency than most other embedded database management systems, but not as much as client/server RDBMSs like MySQL or PostgreSQL.</li>
<li><strong>No user management:</strong> Database systems often come with support for users, or managed connections with predefined access privileges to the database and tables. Because SQLite reads and writes directly to an ordinary disk file, the only applicable access permissions are the typical access permissions of the underlying operating system. This makes SQLite a poor choice for applications that require multiple users with special access permissions.</li>
<li><strong>Security:</strong> A database engine that uses a server can, in some instances, provide better protection from bugs in the client application than a serverless database like SQLite. For example, stray pointers in a client cannot corrupt memory on the server. Also, because a server is a single persistent process, a client-server database cancontrol data access with more precision than a serverless database, allowing for more fine-grained locking and better concurrency.</li>
</ul>
<h2 id="when-to-use-sqlite">When To Use SQLite</h2>
<ul>
<li><strong>Embedded applications:</strong> SQLite is a great choice of database for applications that need portability and don't require future expansion. Examples include single-user local applications and mobile applications or games.</li>
<li><strong>Disk access replacement:</strong> In cases where an application needs to read and write files to disk directly, it can be beneficial to use SQLite for the additional functionality and simplicity that comes with using SQL.</li>
<li><strong>Testing:</strong> For many applications it can be overkill to test their functionality with a DBMS that uses an additional server process. SQLite has an in-memory mode which can be used to run tests quickly without the overhead of actual database operations, making it an ideal choice for testing.</li>
</ul>
<h2 id="when-not-to-use-sqlite">When Not To Use SQLite</h2>
<ul>
<li><strong>Working with lots of data:</strong> SQLite can technically support a database up to 140TB in size, as long as the disk drive and filesystem also support the database's size requirements. However, the SQLite website <a href="https://www.sqlite.org/whentouse.html">recommends</a> that any database approaching 1TB be housed on a centralized client-server database, as an SQLite database of that size or larger would be difficult to manage.</li>
<li><strong>High write volumes:</strong> SQLite allows only one write operation to take place at any given time, which significantly limits its throughput. If your application requires lots of write operations or multiple concurrent writers, SQLite may not be adequate for your needs.</li>
<li><strong>Network access is required:</strong> Because SQLite is a serverless database, it doesn't provide direct network access to its data. This access is built into the application, so if the data in SQLite is located on a separate machine from the application it will require a high bandwidth engine-to-disk link across the network. This is an expensive, inefficient solution, and in such cases a client-server DBMS may be a better choice.</li>
</ul>
<h1 id="mysql">MySQL</h1>
<p>According to the <a href="https://db-engines.com/en/">DB-Engines Ranking</a>, MySQL has been the most popular open-source RDBMS since the site began tracking database popularity in 2012. It is a feature-rich product that powers many of the world's largest websites and applications, including Twitter, Facebook, Netflix, and Spotify. Getting started with MySQL is relatively straightforward, thanks in large part to its <a href="https://db-engines.com/en/">exhaustive documentation</a> and large <a href="https://forums.mysql.com/">community of developers</a>, as well as the abundance of MySQL-related resources online.</p>
<p>MySQL was designed for speed and reliability, at the expense of full adherence to standard SQL. The MySQL developers continually work towards closer adherence to standard SQL, but it still lags behind other SQL implementations. It does, however, come with various SQL modes and extensions that bring it closer to compliance. Unlike applications using SQLite, applications using a MySQL database access it through a separate daemon process. Because the server process stands between the database and other applications, it allows for greater control over who has access to the database.</p>
<p>MySQL has inspired a wealth of third-party applications, tools, and integrated libraries that extend its functionality and help make it easier to work with. Some of the more widely-used of these third-party tools are <a href="https://www.phpmyadmin.net/">phpMyAdmin</a>, <a href="https://dbeaver.io/">DBeaver</a>, and <a href="https://www.heidisql.com/">HeidiSQL</a>.</p>
<h2 id="mysqls-supported-data-types">MySQL's Supported Data Types</h2>
<p>MySQL's data types can be organized into three broad categories: numeric types, date and time types, and string types.</p>
<h3 id="numeric-types">Numeric types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>tinyint</code></td>
<td>A very small integer. The signed range for this numeric data type is -128 to 127, while the unsigned range is 0 to 255.</td>
</tr>
<tr>
<td><code>smallint</code></td>
<td>A small integer. The signed range for this numeric type is -32768 to 32767, while the unsigned range is 0 to 65535.</td>
</tr>
<tr>
<td><code>mediumint</code></td>
<td>A medium-sized integer. The signed range for this numeric data type is -8388608 to 8388607, while the unsigned range is 0 to 16777215.</td>
</tr>
<tr>
<td><code>int</code> or <code>integer</code></td>
<td>A normal-sized integer. The signed range for this numeric data type is -2147483648 to 2147483647, while the unsigned range is 0 to 4294967295.</td>
</tr>
<tr>
<td><code>bigint</code></td>
<td>A large integer. The signed range for this numeric data type is -9223372036854775808 to 9223372036854775807, while the unsigned range is 0 to 18446744073709551615.</td>
</tr>
<tr>
<td><code>float</code></td>
<td>A small (single-precision) floating-point number.</td>
</tr>
<tr>
<td><code>double</code>, <code>double precision</code>, or <code>real</code></td>
<td>A normal sized (double-precision) floating-point number.</td>
</tr>
<tr>
<td><code>dec</code>, <code>decimal</code>, <code>fixed</code>, or <code>numeric</code></td>
<td>A packed fixed-point number. The display length of entries for this data type is defined when the column is created, and every entry adheres to that length.</td>
</tr>
<tr>
<td><code>bool</code> or <code>boolean</code></td>
<td>A Boolean is a data type that only has two possible values, usually either <code>true</code> or <code>false</code>.</td>
</tr>
<tr>
<td><code>bit</code></td>
<td>A bit value type for which you can specify the number of bits per value, from 1 to 64.</td>
</tr>
</tbody>
</table>
<h3 id="date-and-time-types">Date and time types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>date</code></td>
<td>A date, represented as <code>YYYY-MM-DD</code>.</td>
</tr>
<tr>
<td><code>datetime</code></td>
<td>A timestamp showing the date and time, displayed as <code>YYYY-MM-DD HH:MM:SS</code>.</td>
</tr>
<tr>
<td><code>timestamp</code></td>
<td>A timestamp indicating the amount of time since the <a href="https://en.wikipedia.org/wiki/Unix_time">Unix epoch</a> (00:00:00 on January 1, 1970).</td>
</tr>
<tr>
<td><code>time</code></td>
<td>A time of day, displayed as <code>HH:MM:SS</code>.</td>
</tr>
<tr>
<td><code>year</code></td>
<td>A year expressed in either a 2 or 4 digit format, with 4 digits being the default.</td>
</tr>
</tbody>
</table>
<h3 id="string-types">String types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>char</code></td>
<td>A fixed-length string; entries of this type are padded on the right with spaces to meet the specified length when stored.</td>
</tr>
<tr>
<td><code>varchar</code></td>
<td>A string of variable length.</td>
</tr>
<tr>
<td><code>binary</code></td>
<td>Similar to the <code>char</code> type, but a binary byte string of a specified length rather than a nonbinary character string.</td>
</tr>
<tr>
<td><code>varbinary</code></td>
<td>Similar to the <code>varchar</code> type, but a binary byte string of a variable length rather than a nonbinary character string.</td>
</tr>
<tr>
<td><code>blob</code></td>
<td>A binary string with a maximum length of 65535 (2^16 - 1) bytes of data.</td>
</tr>
<tr>
<td><code>tinyblob</code></td>
<td>A <code>blob</code> column with a maximum length of 255 (2^8 - 1) bytes of data.</td>
</tr>
<tr>
<td><code>mediumblob</code></td>
<td>A <code>blob</code> column with a maximum length of 16777215 (2^24 - 1) bytes of data.</td>
</tr>
<tr>
<td><code>longblob</code></td>
<td>A <code>blob</code> column with a maximum length of 4294967295 (2^32 - 1) bytes of data.</td>
</tr>
<tr>
<td><code>text</code></td>
<td>A string with a maximum length of 65535 (2^16 - 1) characters.</td>
</tr>
<tr>
<td><code>tinytext</code></td>
<td>A <code>text</code> column with a maximum length of 255 (2^8 - 1) characters.</td>
</tr>
<tr>
<td><code>mediumtext</code></td>
<td>A <code>text</code> column with a maximum length of 16777215 (2^24 - 1) characters.</td>
</tr>
<tr>
<td><code>longtext</code></td>
<td>A <code>text</code>  column with a maximum length of 4294967295 (2^32 - 1) characters.</td>
</tr>
<tr>
<td><code>enum</code></td>
<td>An enumeration, which is a string object that takes a single value from a list of values that are declared when the table is created.</td>
</tr>
<tr>
<td><code>set</code></td>
<td>Similar to an enumeration, a string object that can have zero or more values, each of which must be chosen from a list of allowed values that are specified when the table is created.</td>
</tr>
</tbody>
</table>
<h2 id="advantages-of-mysql">Advantages of MySQL</h2>
<ul>
<li><strong>Popularity and ease of use:</strong> As one of the world's most popular database systems, there's no shortage of database administrators who have experience working with MySQL. Likewise, there's an abundance of documentation in print and online on how to install and manage a MySQL database, as well as a number of third-party tools — such as phpMyAdmin — that aim to simplify the process of getting started with the database.</li>
<li><strong>Security:</strong> MySQL comes installed with a script that helps you to improve the security of your database by setting the installation's password security level, defining a password for the root user, removing anonymous accounts, and removing test databases that are, by default, accessible to all users. Also, unlike SQLite, MySQL does support user management and allows you to grant access privileges on a user-by-user basis.</li>
<li><strong>Speed:</strong> By choosing not to implement certain features of SQL, the MySQL developers were able to prioritize speed. While more recent benchmark tests show that other RDBMSs like PostgreSQL can match or at least come close to MySQL in terms of speed, MySQL still holds a reputation as an exceedingly fast database solution.</li>
<li><strong>Replication:</strong> MySQL supports a number of different types of <a href="https://en.wikipedia.org/wiki/Replication_(computing)#Database_replication"><em>replication</em></a>, which is the practice of sharing information across two or more hosts to help improve reliability, availability, and fault-tolerance. This is helpful for setting up a database backup solution or <a href="https://en.wikipedia.org/wiki/Scalability#HORIZONTAL-SCALING"><em>horizontally scaling</em></a> one's database.</li>
</ul>
<h2 id="disadvantages-of-mysql">Disadvantages of MySQL</h2>
<ul>
<li><strong>Known limitations:</strong> Because MySQL was designed for speed and ease of use rather than full SQL compliance, it comes with certain functional limitations. For example, it <a href="https://fthiella.github.io/mysql-full-outer-join/">lacks support for <code>FULL JOIN</code> clauses</a>.</li>
<li><strong>Licensing and proprietary features:</strong> MySQL is <em>dual-licensed</em> software, with a free and open-source community edition licensed under <a href="https://en.wikipedia.org/wiki/GNU_General_Public_License#Version_2">GPLv2</a> and several paid commercial editions released under proprietary licenses. Because of this, some features and plugins are only available for the proprietary editions.</li>
<li><strong>Slowed development:</strong> Since the MySQL project was acquired by Sun Microsystems in 2008, and later by Oracle Corporation in 2009, there have been complaints from users that the development process for the DBMS has slowed down significantly, as the community no longer has the agency to quickly react to problems and implement changes.</li>
</ul>
<h2 id="when-to-use-mysql">When To Use MySQL</h2>
<ul>
<li><strong>Distributed operations:</strong> MySQL's replication support makes it a great choice for distributed database setups like <a href="https://dev.mysql.com/doc/refman/8.0/en/group-replication-primary-secondary-replication.html">primary-secondary</a> or <a href="https://dev.mysql.com/doc/refman/8.0/en/group-replication-summary.html">primary-primary</a> architectures.</li>
<li><strong>Websites and web applications:</strong> MySQL powers many websites and applications across the internet. This is, in large part, thanks to how easy it is to install and set up a MySQL database, as well as its overall speed and scalability in the long run.</li>
<li><strong>Expected future growth:</strong> MySQL's replication support can help facilitate horizontal scaling. Additionally, it's a relatively straightforward process to upgrade to a commercial MySQL product, like MySQL Cluster, which supports automatic sharding, another horizontal scaling process.</li>
</ul>
<h2 id="when-not-to-use-mysql">When Not To Use MySQL</h2>
<ul>
<li><strong>SQL compliance is necessary:</strong> Since MySQL does not try to implement the full SQL standard, this tool is not completely SQL compliant. If complete or even near-complete SQL compliance is a must for your use case, you may want to use a more fully compliant DBMS.</li>
<li><strong>Concurrency and large data volumes:</strong> Although MySQL generally performs well with read-heavy operations, concurrent read-writes can be problematic. If your application will have many users writing data to it at once, another RDBMS like PostgreSQL might be a better choice of database.</li>
</ul>
<h1 id="postgresql">PostgreSQL</h1>
<p>PostgreSQL, also known as Postgres, bills itself as &quot;the most advanced open-source relational database in the world&quot;. It was created with the goal of being highly extensible and standards compliant. PostgreSQL is an object-relational database, meaning that although it's primarily a relational database it also includes features — like table inheritance and function overloading — that are more often associated with <a href="https://en.wikipedia.org/wiki/Object_database"><em>object databases</em></a>.</p>
<p>Postgres is capable of efficiently handling multiple tasks at the same time, a characteristic known as concurrency. It achieves this without read locks thanks to its implementation of <a href="https://en.wikipedia.org/wiki/Multiversion_concurrency_control">Multiversion Concurrency Control (MVCC)</a>, which ensures the atomicity, consistency, isolation, and durability of its transactions, also known as ACID compliance.</p>
<p>PostgreSQL isn't as widely used as MySQL, but there are still a number of third-party tools and libraries designed to simplify working with with PostgreSQL, including <a href="https://www.pgadmin.org/">pgAdmin</a> and <a href="https://github.com/paxa/postbird">Postbird</a>.</p>
<h2 id="postgresqls-supported-data-types">PostgreSQL's Supported Data Types</h2>
<p>PostgreSQL supports numeric, string, and date and time data types like MySQL. In addition, it supports data types for geometric shapes, network addresses, bit strings, text searches, and JSON entries, as well as several idiosyncratic data types.</p>
<h3 id="numeric-types-2">Numeric types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>bigint</code></td>
<td>A signed 8 byte integer.</td>
</tr>
<tr>
<td><code>bigserial</code></td>
<td>An autoincrementing 8 byte integer.</td>
</tr>
<tr>
<td><code>double precision</code></td>
<td>An 8 byte double precision floating-point number.</td>
</tr>
<tr>
<td><code>integer</code></td>
<td>A signed 4 byte integer.</td>
</tr>
<tr>
<td><code>numeric</code> or <code>decimal</code></td>
<td>An number of selectable precision, recommended for use in cases where exactness is crucial, such as monetary amounts.</td>
</tr>
<tr>
<td><code>real</code></td>
<td>A 4 byte single precision floating-point number.</td>
</tr>
<tr>
<td><code>smallint</code></td>
<td>A signed 2 byte integer.</td>
</tr>
<tr>
<td><code>smallserial</code></td>
<td>An autoincrementing 2 byte integer.</td>
</tr>
<tr>
<td><code>serial</code></td>
<td>An autoincrementing 4 byte integer.</td>
</tr>
</tbody>
</table>
<h3 id="character-types">Character types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>character</code></td>
<td>A character string with a specified fixed length.</td>
</tr>
<tr>
<td><code>character varying</code> or <code>varchar</code></td>
<td>A character string with a variable but limited length.</td>
</tr>
<tr>
<td><code>text</code></td>
<td>A character string of a variable, unlimited length.</td>
</tr>
</tbody>
</table>
<h3 id="date-and-time-types-2">Date and time types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>date</code></td>
<td>A calendar date consisting of the day, month, and year.</td>
</tr>
<tr>
<td><code>interval</code></td>
<td>A time span.</td>
</tr>
<tr>
<td><code>time</code> or <code>time without time zone</code></td>
<td>A time of day, not including the time zone.</td>
</tr>
<tr>
<td><code>time with time zone</code></td>
<td>A time of day, including the time zone.</td>
</tr>
<tr>
<td><code>timestamp</code> or <code>timestamp without time zone</code></td>
<td>A date and time, not including the time zone.</td>
</tr>
<tr>
<td><code>timestamp with time zone</code></td>
<td>A date and time, including the time zone.</td>
</tr>
</tbody>
</table>
<h3 id="geometric-types">Geometric types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>box</code></td>
<td>A rectangular box on a plane.</td>
</tr>
<tr>
<td><code>circle</code></td>
<td>A circle on a plane.</td>
</tr>
<tr>
<td><code>line</code></td>
<td>An infinite line on a plane.</td>
</tr>
<tr>
<td><code>lseg</code></td>
<td>A line segment on a plane.</td>
</tr>
<tr>
<td><code>path</code></td>
<td>A geometric path on a plane.</td>
</tr>
<tr>
<td><code>point</code></td>
<td>A geometric point on a plane.</td>
</tr>
<tr>
<td><code>polygon</code></td>
<td>A closed geometric path on a plane.</td>
</tr>
</tbody>
</table>
<h3 id="network-address-types">Network address types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>cidr</code></td>
<td>An IPv4 or IPv6 network address.</td>
</tr>
<tr>
<td><code>inet</code></td>
<td>An IPv4 or IPv6 host address.</td>
</tr>
<tr>
<td><code>macaddr</code></td>
<td>A Media Access Control (MAC) address.</td>
</tr>
</tbody>
</table>
<h3 id="bit-string-types">Bit string types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>bit</code></td>
<td>A fixed-length bit string.</td>
</tr>
<tr>
<td><code>bit varying</code></td>
<td>A variable-length bit string.</td>
</tr>
</tbody>
</table>
<h3 id="text-search-types">Text search types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>tsquery</code></td>
<td>A text search query.</td>
</tr>
<tr>
<td><code>tsvector</code></td>
<td>A text search document.</td>
</tr>
</tbody>
</table>
<h3 id="json-types">JSON types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>json</code></td>
<td>Textual JSON data.</td>
</tr>
<tr>
<td><code>jsonb</code></td>
<td>Decomposed binary JSON data.</td>
</tr>
</tbody>
</table>
<h3 id="other-data-types">Other data types:</h3>
<table>
<thead>
<tr>
<th>Data Type</th>
<th>Explanation</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>boolean</code></td>
<td>A logical Boolean, representing either <code>true</code> or <code>false</code>.</td>
</tr>
<tr>
<td><code>bytea</code></td>
<td>Short for &quot;byte array&quot;, this type is used for binary data.</td>
</tr>
<tr>
<td><code>money</code></td>
<td>An amount of currency.</td>
</tr>
<tr>
<td><code>pg_lsn</code></td>
<td>A PostgreSQL Log Sequence Number.</td>
</tr>
<tr>
<td><code>txid_snapshot</code></td>
<td>A user-level transaction ID snapshot.</td>
</tr>
<tr>
<td><code>uuid</code></td>
<td>A universally unique identifier.</td>
</tr>
<tr>
<td><code>xml</code></td>
<td>XML data.</td>
</tr>
</tbody>
</table>
<h2 id="advantages-of-postgresql">Advantages of PostgreSQL</h2>
<ul>
<li><strong>SQL compliance:</strong> More so than SQLite or MySQL, PostgreSQL aims to closely adhere to SQL standards. <a href="https://www.postgresql.org/docs/current/features.html">According to the official PostgreSQL documentation</a>, PostgreSQL supports 160 out of the 179 features required for full core SQL:2011 compliance, in addition to a long list of optional features.</li>
<li><strong>Open-source and community-driven:</strong> A fully open-source project, PostgreSQL's source code is developed by a large and devoted community. Similarly, the Postgres community maintains and contributes to numerous online resources that describe how to work with the DBMS, including the <a href="https://www.postgresql.org/docs/">official documentation</a>, the <a href="https://wiki.postgresql.org/wiki/Main_Page">PostgreSQL wiki</a>, and various online forums.</li>
<li><strong>Extensible:</strong> Users can extend PostgreSQL programmatically and on the fly through its <a href="https://www.postgresql.org/docs/9.0/extend-how.html">catalog-driven operation</a> and its use of <a href="https://en.wikipedia.org/wiki/Dynamic_loading">dynamic loading</a>. One can designate an object code file, such as a shared library, and PostgreSQL will load it as necessary.</li>
</ul>
<h2 id="disadvantages-of-postgresql">Disadvantages of PostgreSQL</h2>
<ul>
<li><strong>Memory performance:</strong> For every new client connection, PostgreSQL forks a new process. Each new process is allocated about 10MB of memory, which can add up quickly for databases with lots of connections. Accordingly, for simple read-heavy operations, PostgreSQL is typically less performant than other RDBMSs, like MySQL.</li>
<li><strong>Popularity:</strong> Although more widely used in recent years, PostgreSQL historically lagged behind MySQL in terms of popularity. One consequence of this is that there are still fewer third-party tools that can help to manage a PostgreSQL database. Similarly, there aren't as many database administrators with experience managing a Postgres database compared to those with MySQL experience.</li>
</ul>
<h2 id="when-to-use-postgresql">When To Use PostgreSQL</h2>
<ul>
<li><strong>Data integrity is important:</strong> PostgreSQL has been fully ACID-compliant since 2001 and implements multiversion currency control to ensure that data remains consistent, making it a strong choice of RDBMS when data integrity is critical.</li>
<li><strong>Integration with other tools:</strong> PostgreSQL is compatible with a wide array of programming languages and platforms. This means that if you ever need to migrate your database to another operating system or integrate it with a specific tool, it will likely be easier with a PostgreSQL database than with another DBMS.</li>
<li><strong>Complex operations:</strong> Postgres supports query plans that can leverage multiple CPUs in order to answer queries with greater speed. This, coupled with its strong support for multiple concurrent writers, makes it a great choice for complex operations like data warehousing and online transaction processing.</li>
</ul>
<h2 id="when-not-to-use-postgresql">When Not To Use PostgreSQL</h2>
<ul>
<li><strong>Speed is imperative:</strong> At the expense of speed, PostgreSQL was designed with extensibility and compatibility in mind. If your project requires the fastest read operations possible, PostgreSQL may not be the best choice of DBMS.</li>
<li><strong>Simple setups:</strong> Because of its large feature set and strong adherence to standard SQL, Postgres can be overkill for simple database setups. For read-heavy operations where speed is required, MySQL is typically a more practical choice.</li>
<li><strong>Complex replication:</strong> Although PostgreSQL does provide strong support for replication, it's still a relatively new feature and some configurations — like a primary-primary architecture — are only possible with extensions. Replication is a more mature feature on MySQL and many users see MySQL's replication to be easier to implement, particularly for those who lack the requisite database and system administration experience.</li>
</ul>
<h1 id="conclusion">Conclusion</h1>
<p>Today, SQLite, MySQL, and PostgreSQL are the three most popular open-source relational database management systems in the world. Each has its own unique features and limitations, and excels in particular scenarios. There are a quite a few variables at play when deciding on an RDBMS, and the choice is rarely as simple as picking the fastest one or the one with the most features. The next time you're in need of a relational database solution, be sure to research these and other tools in depth to find the one that best suits your needs.</p>
<p>If you'd like to learn more about SQL and how to use it to manage a relational database, we encourage you to refer to our <a href="https://www.digitalocean.com/community/tutorials/how-to-manage-sql-database-cheat-sheet">How To Manage an SQL Database</a> cheat sheet. On the other hand, if you'd like to learn about non-relational (or NoSQL) databases, check out our <a href="https://www.digitalocean.com/community/articles/a-comparison-of-nosql-database-management-systems-and-models">Comparison Of NoSQL Database Management Systems</a>.</p>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[innodb 逻辑存储结构]]></title>
        <id>https://faded.auspicious.space/post/innodb-logical-storage-structure/</id>
        <link href="https://faded.auspicious.space/post/innodb-logical-storage-structure/">
        </link>
        <updated>2020-05-19T04:44:48.000Z</updated>
        <summary type="html"><![CDATA[<blockquote>
<p><a href="https://juejin.im/post/5e395c18518825494b3cbe88">MySQL相关（番外篇）- innodb 逻辑存储结构</a></p>
</blockquote>
]]></summary>
        <content type="html"><![CDATA[<blockquote>
<p><a href="https://juejin.im/post/5e395c18518825494b3cbe88">MySQL相关（番外篇）- innodb 逻辑存储结构</a></p>
</blockquote>
<!-- more -->
<h1 id="前言">前言</h1>
<p>前面已经写了有两篇章长度的文章，第三篇我一直在寻思着要写什么（其实并没有），按照脑图来的话，这篇文章我们该来讲讲关于索引的知识了，这可是 MySQL 性能优化很关键的知识点，千万千万不要错过，不过我这里会相对比较深入地探究，相信大家读完之后多少会有点收获。</p>
<p>先送上两张飞机票🛬还没读过前面文章的伙伴可以先前往阅读，由浅入深：</p>
<ul>
<li><a href="https://blog.csdn.net/weixin_42669785/article/details/104107328">MySQL相关（一）- 一条查询语句是如何执行的</a></li>
<li><a href="https://blog.csdn.net/weixin_42669785/article/details/104114754">MySQL相关（二）- 一条更新语句是如何执行的</a></li>
</ul>
<p>由于索引的知识点比较多，官网的内容也很多，如果大家想详细了解可以到官网，想先通读了解的话可以先看看我对索引的总结，这一章节分为三部分来讲：</p>
<ol>
<li>innodb 逻辑存储结构需要了解，作为番外篇<br>
<a href="https://blog.csdn.net/weixin_42669785/article/details/104171284">MySQL相关（番外篇）- innodb 逻辑存储结构</a>；</li>
<li>索引的数据结构也作为另外的篇章，通过对查询算法的数据模型进行演算分析<br>
<a href="https://blog.csdn.net/weixin_42669785/article/details/104114754">MySQL相关（三）- 索引数据模型推演及 B+Tree 的详细介绍</a>；</li>
<li>对索引的使用及优化规则也会作为单独的篇章<br>
<a href="https://blog.csdn.net/weixin_42669785/article/details/104128890">MySQL相关（四）- 性能优化关键点索引</a><br>
<img src="https://faded.auspicious.space/post-images/1589863961002.jpg" alt="" loading="lazy"></li>
</ol>
<h1 id="正文">正文</h1>
<h2 id="innodb-逻辑存储结构">innodb 逻辑存储结构</h2>
<p><a href="https://dev.mysql.com/doc/refman/5.7/en/innodb-disk-management.html">https://dev.mysql.com/doc/refman/5.7/en/innodb-disk-management.html</a><br>
<a href="https://dev.mysql.com/doc/refman/5.7/en/innodb-file-space.html">https://dev.mysql.com/doc/refman/5.7/en/innodb-file-space.html</a></p>
<p>MySQL 的存储结构分为 5 级：表空间、段、簇、页、行。<br>
<img src="https://faded.auspicious.space/post-images/1589864049177.png" alt="" loading="lazy"></p>
<h2 id="表空间-table-space">表空间 Table Space</h2>
<p>上一篇文章讲磁盘结构的时候提到过，表空间可以看做是 InnoDB 存储引擎逻辑结构的最高层，所有的数据都存放在表空间中。分为：系统表空间、独占表空间、通用表空间、 临时表空间、Undo 表空间。</p>
<h2 id="段-segment">段 Segment</h2>
<p>表空间是由各个段组成的，常见的段有数据段、索引段、回滚段等，段是一个逻辑的概念。一个 <code>ibd</code> 文件（独立表空间文件）里面会由很多个段组成。</p>
<p>创建一个索引会创建两个段，一个是索引段：<code>leaf node segment</code>，一个是数据段：<code>non-leaf node segment</code>。索引段管理非叶子节点的数据。数据段管理叶子节点的数据。</p>
<p>也就是说，一个表的段数，就是索引的个数乘以 2。</p>
<h2 id="簇-extent">簇 Extent</h2>
<p>一个段（Segment）又由很多的簇（也可以叫区）组成，每个区的大小是 1MB（64个连续的页）。</p>
<p>每一个段至少会有一个簇，一个段所管理的空间大小是无限的，可以一直扩展下去，但是扩展的最小单位就是簇。</p>
<h2 id="页-page">页 page</h2>
<p>为了高效管理物理空间，对簇进一步细分，就得到了页。簇是由连续的页（Page）组成的空间，一个簇中有 64 个连续的页。 （1MB／16KB = 64）。这些页面在物理上和逻辑上都是连续的。</p>
<p>跟大多数数据库一样，InnoDB 也有页的概念（也可以称为块），每个页默认 16KB。</p>
<p>页是 InnoDB 存储引擎磁盘管理的最小单位，通过 <code>innodb_page_size</code> 设置。</p>
<p>一个表空间最多拥有 2^32 个页，默认情况下一个页的大小为 16KB，也就是说一个表空间最多存储 64TB 的数据。</p>
<p>注意，文件系统中，也有页的概念。</p>
<p>操作系统和内存打交道，最小的单位是页 Page。文件系统的内存页通常是 4K。</p>
<figure data-type="image" tabindex="1"><img src="https://faded.auspicious.space/post-images/1589864130201.png" alt="" loading="lazy"></figure>
<pre><code class="language-sql">SHOW VARIABLES LIKE 'innodb_page_size';
</code></pre>
<p>假设一行数据大小是 1K，那么一个数据页可以放 16 行这样的数据。</p>
<p>举例：一个页放 3 行数据。<br>
<img src="https://faded.auspicious.space/post-images/1589864219950.png" alt="" loading="lazy"></p>
<p>往表中插入数据时，如果一个页面已经写完，产生一个新的叶页面。如果一个簇的所有的页面都被用完，会从当前页面所在段新分配一个簇。</p>
<p>如果数据不是连续的，往已经写满的页中插入数据，会导致叶页面分裂：<br>
<img src="https://faded.auspicious.space/post-images/1589864251940.png" alt="" loading="lazy"></p>
<figure data-type="image" tabindex="2"><img src="https://faded.auspicious.space/post-images/1589864269340.png" alt="" loading="lazy"></figure>
<h2 id="行-row仅供了解">行 Row（仅供了解）</h2>
<p>InnoDB 存储引擎是面向行的（row-oriented），也就是说数据的存放按行进行存放。</p>
<p><a href="https://dev.mysql.com/doc/refman/5.7/en/innodb-row-format.html">https://dev.mysql.com/doc/refman/5.7/en/innodb-row-format.html</a></p>
<p>Antelope[ˈæntɪləʊp]（羚羊）是 InnoDB 内置的文件格式，有两种行格式：</p>
<ul>
<li>REDUNDANT[rɪˈdʌndənt] Row Format</li>
<li>COMPACT Row Format（5.6 默认）</li>
</ul>
<p>Barracuda[ˌbærəˈkjuːdə]（梭子鱼）是 InnoDB Plugin 支持的文件格式，新增了 两种行格式：</p>
<ul>
<li>DYNAMIC Row Format（5.7 默认）</li>
<li>COMPRESSED Row Format</li>
</ul>
<table>
<thead>
<tr>
<th>文件格式</th>
<th>行格式</th>
<th>描述</th>
</tr>
</thead>
<tbody>
<tr>
<td>Antelope （Innodb-base）</td>
<td>ROW_FORMAT=COMPACT ROW_FORMAT=REDUNDANT</td>
<td>Compact 和 redumdant 的区别在就是在于首部的存 存内容区别。 compact 的存储格式为首部为一个非 NULL 的变长字 段长度列表 redundant 的存储格式为首部是一个字段长度偏移 列表（每个字段占用的字节长度及其相应的位移）。 在 Antelope 中对于变长字段，低于 768 字节的，不 会进行 overflow page 存储，某些情况下会减少结果 集 IO.</td>
</tr>
<tr>
<td>Barracuda (innodb-plugin)</td>
<td>ROW_FORMAT=DYNAMIC ROW_FORMAT=COMPRESSED</td>
<td>这两者主要是功能上的区别功能上的。 另外在行 里的变长字段和 Antelope 的区别是只存 20 个字节， 其它的 overflow page 存储。 另外这两都需要开启 innodb_file_per_table=1</td>
</tr>
</tbody>
</table>
<p><code>innodb_file_format</code> 在配置文件中指定；<code>row_format</code> 则在创建数据表时指定。</p>
<pre><code class="language-bash">SHOW VARIABLES LIKE &quot;%innodb_file_format%&quot;;
SET GLOBAL innodb_file_format=Barracuda;
</code></pre>
<figure data-type="image" tabindex="3"><img src="https://faded.auspicious.space/post-images/1589864494186.png" alt="" loading="lazy"></figure>
<p>在创建表的时候可以指定行格式。</p>
<pre><code class="language-sql">CREATE TABLE tf1 (c1 INT PRIMARY KEY) ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=8;
</code></pre>
<p>查看行格式：</p>
<pre><code class="language-bash">SHOW TABLE STATUS LIKE 'student' \G;
</code></pre>
<figure data-type="image" tabindex="4"><img src="https://faded.auspicious.space/post-images/1589864547767.png" alt="" loading="lazy"></figure>
<p>这一块的内容主要是让大家了解页 page 的概念。 接下来我们可以到<a href="https://blog.csdn.net/weixin_42669785/article/details/104171323">MySQL相关（三）- 索引数据模型推演及 B+Tree 的详细介绍</a>查看关于索引数据结构的演算。</p>
]]></content>
    </entry>
</feed>