<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Daniel Parham on Medium]]></title>
        <description><![CDATA[Stories by Daniel Parham on Medium]]></description>
        <link>https://medium.com/@dparha012?source=rss-7d673c4e09d1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*QAu20FeJobgwgRuZ.</url>
            <title>Stories by Daniel Parham on Medium</title>
            <link>https://medium.com/@dparha012?source=rss-7d673c4e09d1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 21:40:13 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dparha012/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[What Happens When You Type a Website in a Browser]]></title>
            <link>https://medium.com/@dparha012/what-happens-when-you-type-a-website-in-a-browser-e93e05f95cfe?source=rss-7d673c4e09d1------2</link>
            <guid isPermaLink="false">https://medium.com/p/e93e05f95cfe</guid>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Daniel Parham]]></dc:creator>
            <pubDate>Mon, 09 Apr 2018 05:28:32 GMT</pubDate>
            <atom:updated>2018-04-09T05:28:32.619Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*FraUK69tD8bwk2-RJW8RcA.png" /></figure><p>When one types a website’s name into a web browser they are really activating a dns system that allows them to connect to a web site’s servers and databases that manifests itself in an interactive webpage. Initially the domain name type into the browser needs to be translated into the ip address of the website’s web servers which is a process in which the domain name is searched for through a series of servers that eventually, if the domain name exists, results in an A record which holds the information necessary to find the ip address. This information as any data sent over a network, is turned into packets and managed according to a protocol TCP that puts the info in the correct packets, in the correct order. TCP works hand-in-hand with IP which is an address that identifies the location of the server being requested. It is important to have a secure server so that the right people have access to the data on it and those who aren’t authorized do not. The firewall protects the server through analyze the various ports the servers accesses and chooses which ports are going to be used and which types of signals are going to be allowed in which ports. This can make security a bit easier to handle i.e. if a signal is coming through a closed port then one can assume that it is a foreign threat or an ill-sent message. To further security, using the https protocol to encrypt the packets as they are sent across the network. This is provides piece of mind for the customer/user when they visit a site and/or application.</p><p>One might think that security is just dealing with unwanted traffic, but it also has to deal with an unexpected influx of traffic, which is where load-balancing comes into play. The load-balancer is a separate server that manages the data requests in a manner that lowers that chances that any one web server becomes overwhelmed with requests from users. There are a numerous amount of algorithms these load-balancers use and they all have different pros and cons but they all have the purpose to deal with scalability. The web server is the part of the system hierarchy that manages user request. These servers are connected to the databases that have the objects, if dealing with object-oriented language, which is what the user really wants. The data which is stored once retrieved creates an interactive application that can create a place for the user to gather information and use it in the way they desire.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e93e05f95cfe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python3: Mutable, Immutable… Everything is Object!]]></title>
            <link>https://medium.com/@dparha012/python3-mutable-immutable-everything-is-object-6ba761a490b1?source=rss-7d673c4e09d1------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ba761a490b1</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[immutable]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[objects]]></category>
            <category><![CDATA[mutable]]></category>
            <dc:creator><![CDATA[Daniel Parham]]></dc:creator>
            <pubDate>Wed, 10 Jan 2018 06:20:31 GMT</pubDate>
            <atom:updated>2018-01-10T06:20:31.482Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*6zixRNxUrbTmVfl7k7dpJw.jpeg" /></figure><p>In Python everything from data types (integers, floats, list, etc.) to classes is an object. This provides a level of consistency across the entire language that can make it a bit easier to deal with once one becomes accustomed to its features as well as the syntax. There are a few differences however between the data types that, if not properly understood, can be the source of a bit of confusion for the programmer and hopefully in this article there is information that can help to avoid some of the pitfalls that some users fall into.</p><p>The computer itself must use memory in order to operate in the manner that it does and programming languages must deal with memory in order for the computer to carry out the instructions. Python’s data types are assigned a place in memory when created and if one would want to know where it is in the memory python provides a function that returns this location to the programmer called id(). The id() function will return an address that corresponds with the argument passed e.g.</p><pre>&gt;&gt;&gt; a = 10<br>&gt;&gt;&gt; id(a)<br>&gt;&gt;&gt; 10088576<br>&gt;&gt;&gt; type(a)<br>&gt;&gt;&gt; &lt;class &#39;int&#39;&gt;</pre><p>The code above assigns a name, in this case “a”, to the integer 10 and we can see by passing it to the id function that there is indeed an address that has been reserved for the use of the variable. We also introduced a new function type() which returns the data type in this class an integer. As said early everything in python is an object and that includes data types which explains why the return value of type() is &lt;class ‘int’&gt; instead of &lt;‘int’&gt;. Remember everything is an object including classes.</p><p>Data types can fall into two categories mutable and immutable. Once generated, a mutable type can be changed in place (this is how it is referred to in the pythonic community) while an immutable type cannot. Strings for example are immutable and cannot be changed so whenever an operation is performed on a string a new string in a new location is created:</p><pre>&gt;&gt;&gt; s = &quot;hello&quot;<br>&gt;&gt;&gt; print(s)<br>&gt;&gt;&gt; hello<br>&gt;&gt;&gt; id(s)<br>&gt;&gt;&gt; 10088573<br>&gt;&gt;&gt; s *= 3<br>&gt;&gt;&gt; print(s)<br>&gt;&gt;&gt; hellohellohello<br>&gt;&gt;&gt; id(s)<br>&gt;&gt;&gt; 30045573</pre><p>The code above illustrates how python creates a new string in a new location in memory instead of changing the original string that was created. If a data type is mutable it can be changed in place. Lists are a popular type that is mutable when the following code is run we can see that the list is changed in place:</p><pre>&gt;&gt;&gt; l = [&quot;hello&quot;]<br>&gt;&gt;&gt; print(l)<br>&gt;&gt;&gt; [&quot;hello&quot;]<br>&gt;&gt;&gt; id(l)<br>&gt;&gt;&gt; 25488573<br>&gt;&gt;&gt; l + [&quot;world&quot;]<br>&gt;&gt;&gt; print(l)<br>&gt;&gt;&gt; [&quot;hello&quot;, &quot;world&quot;]<br>&gt;&gt;&gt; id(l)<br>&gt;&gt;&gt; 25488573</pre><p>We can see that the list, which if you are curious behaves sort of like an array in other languages with a few differences of course, is changed but the address has not confirming that we are dealing with the same list instead of a new one. This is what is meant by “in place”, the “place” in the statement “in place” can be thought of as the address in memory if that makes it easier to think about.</p><p>In programing, the way in which functions receive their arguments usually falls into two different categories: “call by value” and “call by reference”. Call by value is something used in C and C++ in which the expression is evaluated to a certain value and the variable within the function only exist in the function. Meaning if I have a variable “a” in a function, once the function exits, “a” no longer exists. Call by reference refers to an address so that once the function exits the modifications made to the variable persists. If you are familiar with pointers in C this may sound familiar.</p><p>Python functions use a method called “call by object” or “call by object reference” (it’s the same thing just different names). If an immutable type (or object, remember everything is an object in python) is passed to a function the reference to the object is passed into the function and because it cannot be changed it won’t be e.g.</p><pre>&gt;&gt;&gt; def inc(num):<br>...    num += 1<br>&gt;&gt;&gt; a = 1<br>&gt;&gt;&gt; inc(a)<br>&gt;&gt;&gt; print(a)<br>&gt;&gt;&gt; 1</pre><p>Integers are immutable like strings so when some operation is called on the variable “a” in the function it creates a new variable in a new location leaving “a” unchanged. However if a list or any other mutable object was passed into a function it would change the object “in place”. This is the consistency I was talking about earlier in this article. Treating everything as an object makes it so that whenever so weird may happen that is difficult to understand, thinking about the make up of objects and the particular one you are working with allows for the potential to get unstuck and provides a bit of clarity that could make python a bit simpler to understand. Below are websites/videos that should help clarify things a bit for me and hopefully you find them and this article helpful.</p><ul><li><a href="https://www.python-course.eu/passing_arguments.php">Python Tutorial: Passing Arguments</a></li><li><a href="https://stackoverflow.com/questions/245192/what-are-first-class-objects">What are &quot;first class&quot; objects?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ba761a490b1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Static Libraries in C: What they are and how to use them]]></title>
            <link>https://medium.com/@dparha012/static-libraries-in-c-what-they-are-and-how-to-use-them-a3f5caddb69a?source=rss-7d673c4e09d1------2</link>
            <guid isPermaLink="false">https://medium.com/p/a3f5caddb69a</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[static-library]]></category>
            <category><![CDATA[c-programming]]></category>
            <category><![CDATA[ar-linux-command]]></category>
            <category><![CDATA[programming-library]]></category>
            <dc:creator><![CDATA[Daniel Parham]]></dc:creator>
            <pubDate>Sun, 08 Oct 2017 23:36:04 GMT</pubDate>
            <atom:updated>2017-10-08T23:36:04.180Z</atom:updated>
            <content:encoded><![CDATA[<p>So if you are familiar with C at all something that might come to mind are functions. In addition if you like me have been learning how to program then there is the possibility you’ve been making a lot of functions as of late. Well if you’re thinking about how much “fun” it’s been and wondering if you’ll just be making programs whose purpose is to complete some mundane task like returning the length of string or converting a character to an integer just to be used later then don’t fear because you probably won’t have to do that as much as you think.</p><p>This is where libraries come in. Libraries are first and foremost files. They are simply files used by programmers to hold object files that you might use later. What are object files? Well, they can be a lot of things, and one of these potential manifestations are functions. Yes functions! These files are full of functions waiting to be used to help save a lot of brain power and a lot of time so the engineer can focus on the bigger picture. Now there are two types of these libraries: static and dynamic, also known as shared libraries, but don’t worry about that because we’ll be discussing only the former today.</p><p>So libraries, as mentioned before, are essentially files that hold object files that the coder is then able to use in their own functions. How is this possible and how do they work. So say for example you would like to know the string length and would rather find this out without writing your own function. Well you can simple include the string.h header file at the top of your program and now you can call that function and use it without making a function. This is possible because of libraries. The static library in particular copies the necessary code to your program during compilation so that the computer understands what strlen does and by doing so saves you time from having to write the code yourself. The timing in which this occurs has advantages as well as it does not interfere with runtime. The library is only active during the compilation step of making an executable and so be the time the program runs it has everything it needs to function the way you want it to.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/259/1*qLLwik0cVBObBXiGLMTO4w.png" /><figcaption>The coding process for building a static library</figcaption></figure><p>The way one builds a library is fairly simply which I understand might now be what the reader wants to hear/read at the moment but humor me for a moment as I elaborate a bit. There is a command in linux that takes all of the object files in the current directory and creates a library for you and it’s called ar, for archive. So what one needs to do is type ar followed by the name you would like to give your library ending with a period and an a (library.a)and then the files that one would like to be in there. Now with many programs in linux there are flags and with this command you would use the r and c flags. The r flag “replaces” object files that are old versions of object files that are already in the library but only if the ones you are adding are newer. So say you want to replace strlen in a library that already has that file. Once modified you would use the r flag to tell the computer to replace the old strlen file in your library with the newly modified version. The c flag is if the library does not currently exist and needs to be “created”. This only comes into play if it does not already exist, if it does the files will just be moved into the library which is already there. I would recommend using the man command to take a look at ar just get more familiar with it but those are the bare essentials of how to create a static library.</p><p>However, there are some drawbacks to the way static libraries work. Say I want to build an app and I would like to use static libraries. Well, once completed, all the user would need to do in order to be able to use it would be to download the app, install it and now they are free to explore the wonders of what’s been created. However the size of that app would be dependent on the amount of libraries that have been used. Remember that the static library is accessed during compilation and the code is copied onto your code so that computer knows what the functions being used are doing. Well because of that the size of the app grows. So say we’ve used 100 static libraries, the app is now going to be a lot bigger than it was before the compilation process because of all the code copied from the various libraries. So now we have to make sure to manage the size of the app while coding and think about how big it will be using x amount of static libraries.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/397/1*8XBejcZL1MRy19hoN4_fUg.jpeg" /><figcaption>Static library combining with written code</figcaption></figure><p>Why does memory matter you may ask. Well, if this app is for a computer maybe not so much (these are desktop apps) but if it’s for phone usage (mobile app) then it could be the difference between life and death for your app. Users only have a finite amount of space on their phones and as a developer you want to make your app easy to use in every way which means if your app takes space away from other apps that the user also desires they might have to compare applications yours vs. this other app. Now if you’re confident that your app is the best and no one will choose the alternative over yours then great but the company you work for or the venture capitalist firm that is funding you might not want to take that chance, especially with money on the line and your word being all that they have to go on (higher ups may not have coding knowledge that would help convince them of the effectiveness of your app and even so may decide more is needed to warrant the size of it). So in making your app smaller, even though libraries may need to be downloaded, you would potentially minimize the amount of times the user has to decide with your app and another as far which to download. So I hope this has helped a bit and if you have any more question I would start at the video link below. It’s a lot simpler and if you’re like me a video instead of article works every now and then. Happy coding!</p><p><a href="https://www.youtube.com/watch?v=-vp9cFQCQCo">https://www.youtube.com/watch?v=-vp9cFQCQCo</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a3f5caddb69a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GCC: A brief overview]]></title>
            <link>https://medium.com/@dparha012/gcc-a-brief-overview-d298af2dbee0?source=rss-7d673c4e09d1------2</link>
            <guid isPermaLink="false">https://medium.com/p/d298af2dbee0</guid>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Daniel Parham]]></dc:creator>
            <pubDate>Sun, 17 Sep 2017 07:55:47 GMT</pubDate>
            <atom:updated>2017-09-17T07:55:47.893Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*jw4VkBs-E8eI2IqHVh3BBQ.jpeg" /></figure><p>GCC is something one might here often in conversations about software development or other various discussions revolving around programming but might get lost in all of talk of algorithms, loops, and different techniques implemented in creating interesting and competent blocks of code. The Gnu Compiler Collection is, however, an integral part of creating executable programs that do all the amazing things that users enjoy but how exactly does it work?</p><p>Like many things a software engineer does using GCC involves the terminal and within that the shell known as BASH in which there are a number of commands that, once GCC is properly installed and running properly, activates certain functions within the compiler that then can work with code that has been written. One sure command is simply typing “gcc” followed by a file name in order to begin a four step process at the end of which a usable file that is essential a set of instructions that the computer can understand.</p><p>The compiler although until now has been discussed in this blog as a singular entity, it can also be represented as a series of tools that each perform a specific job that when done in the correct order results in the target program. Now the computer needs to be able to understand what the engineer tells it but the problem is that the language it can read is difficult for humans to comprehend and manipulate in a way that is masterful. So a fix to this predicament is creating other languages that is a bit easier for people to read and write programs with but as said before the computer only understands one way of “speaking” and that is machine language. It is the compiler’s job to transform the source program which is composed with the programming language which is legible for people into terms the computer can read.</p><p>Translating a programming language into machine code might seem like a simple enough task however there are a number of steps the compiler must go through to make this possible. The user must enter a terminal and, once GCC is installed and a source file has been created, type the command gcc followed by the file name, for this example let’s call it “main.c”. So gcc main.c has been entered into the terminal and here is where the compiler springs into action. There are many steps in the process but for the purpose of brevity and hopefully a better understanding as it can be a lot information the more specific one gets we’ll stick with a general overview of the process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/1*sGpD8iQfdTsXUa5HM63qSg.jpeg" /></figure><p>A source program has been written and the user has saved it in a file name main.c and asked the compiler to produce a version of it that the computer can use by type gcc main.c. Source code can often times be a collection of different modules that are not all located in the same area which the are retrieved and grouped together by a separate program known as the preprocessor. In addition to bringing together the source code the preprocessor may also expand parts of the code called macros into a readable machine language. The preprocessor then outputs the modified version of the source code which is then sent through the “compiler” itself which changes the code into assembly language which is much easier to output and debug as well. The assembler then receives said assembly language as input and translates it into the machine language the computer is familiar with. However there are often parts of program that reference libraries or source code that is located elsewhere and in order for it to work. It’s like if one were to follow instructions for building a dog house and there is a need for a hammer which is in the garage. Even though the instructions can be understood, there are tools that are not present at the moment. The linker is the beginning of the final part of the process and if there are libraries or if there is a memory location in a separate file referenced in the current one the linker is like the path to the garage, it provides a way for the program to use these external objects. The second piece of the final part is the loader which brings all the executable object files together and places them in the memory so that they are ready to be used. So continuing with the dog house analogy, if the linker is the sidewalk then the loader would be someone who goes to the garage and gets all the necessary materials, brings them back, and places them in an area where they are accessible to the builder. Finally the source code has been transformed into a target program that is ready to be used by the computer whenever the user asks. Hope this has been helpfully, there are some great sources on the internet and in various books so if you are need of more in depth explanations or clarifications the information is out there.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d298af2dbee0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hard Links vs. “Soft”(Symbolic) Links]]></title>
            <link>https://medium.com/@dparha012/hard-links-vs-soft-symbolic-links-bf72be2bf6c6?source=rss-7d673c4e09d1------2</link>
            <guid isPermaLink="false">https://medium.com/p/bf72be2bf6c6</guid>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Daniel Parham]]></dc:creator>
            <pubDate>Tue, 12 Sep 2017 23:39:23 GMT</pubDate>
            <atom:updated>2017-09-12T23:39:23.349Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/206/1*IjOyRW54XeIJXYkEj1tsgw.jpeg" /></figure><p>In Unix, a file is essentially a link to an inode, which is a type of data structure in linux that has information stored in it. The data in the file is actually located in the inode and the file itself links to said inode so that when one access the file it link to the inode so that it may access the information stored within. The user, along with creating files, can create links as well that have various uses and implications depending on the situation.</p><p>The two types of links in Unix are hard links and soft links and the two have a few similarities as well as a number of differences as well. As said before the file’s process of accessing the information stored in it is to utilize the link to the inode with the data is actually located. A hard link is similar in that it is not only also a link, but it also is directly to the inode with the data is stored. This has a few consequences, one of which being if the file is modified in anyway e.g. a name change or deletion, the hard link is not affected. Since the hard link receives its information directly from the inode it does not rely on the file to access the data.</p><p>The second type of link, soft link, is not quite so independent as the hard link. Instead of pointing/linking directly to the inode, it instead attaches itself to the file and then depends on the file to access the data for it. This means that it will feel the effects of the file being deleted as the file is an integral part of the soft link’s connection to the inode which is the actually location of the data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/295/1*MGkKU5y_3spVHaKmgCrTdg.png" /></figure><p>The picture above gives a visual reference in which one can see that the hard link is an independent path to the inode “N1” whereas the soft link is a bit more reliant on the file itself to gain access to the same inode.</p><p>Creating a hard link in the bash shell requires the command ln followed by the target, or the directory in which the link is to be created, followed by the name of the link. So if one were to create a link called “link” to the inode of a file named “stuff” in the current directory, they would enter into the following into the bash command line: ln stuff link. To make a symbolic link one would add a lower case s in the options category of the command i.e. ln -s stuff link. For more information Google is a good resource but if you are serious about learning the shell and eventually using it at a high level the man page of ln provides information on how to create these links and the different ways they can be used.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bf72be2bf6c6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding the Command ls *.c]]></title>
            <link>https://medium.com/@dparha012/understanding-the-command-ls-c-12186eeecc68?source=rss-7d673c4e09d1------2</link>
            <guid isPermaLink="false">https://medium.com/p/12186eeecc68</guid>
            <category><![CDATA[ls-command]]></category>
            <category><![CDATA[wildcard]]></category>
            <category><![CDATA[terminal]]></category>
            <category><![CDATA[beginner-bash-commands]]></category>
            <dc:creator><![CDATA[Daniel Parham]]></dc:creator>
            <pubDate>Tue, 12 Sep 2017 22:54:49 GMT</pubDate>
            <atom:updated>2017-09-18T21:39:59.692Z</atom:updated>
            <content:encoded><![CDATA[<p>Understanding the Command ls *.c</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/270/1*-IdbpvIODFLZiJvRRBAChA.png" /></figure><p>When one opens a terminal emulator they are generally not given a lot of information from the start. So often times, the seasoned programmer will want to know a few things before typing commands to begin building programs, scripts, or whatever else they have planned. One such command that provides some fundamental information to the user is ls which, when written by itself, lists the contents of the current directory. Understanding what is in the current directory can be very useful when performing even the most rudimentary tasks let alone the more complex ones that require lengthy scripts or a mastery of a programming language.</p><p>The command ls, although by itself is very useful, also allows the user to ask of it to list content in files and/or directories that are either in the current directory or elsewhere without having to travel to it. The user can type the file name after a space (ls filename) and it will return a list of files within a file that is matching the name provided. However, there are times when one would like to know the contents multiple files whose filenames that have a pattern in them and when this is the case the user can use a symbol known as a wildcard to communicate this to the shell. The * is a wildcard that stands for ‘any filename’ which when used correctly tells the shell to search for any file with a name that meets certain criteria.</p><p>So when a user types “ls *.c” into the terminal, what the shell sees is first the ls command which means that it is going to be listing contents from the a file/directory possible later to be determined. Next in the command we see the wildcard * which as stated before means ‘any file name’, but there is also a period followed by the letter c that comes after it. This simply means that the user would like the shell to search for and list the contents of any files or directories in the current directory that ends with a dot c (.c). After hitting the return key, the shell sees this command says “list the contents of all files starting with any file name that ends with .c in the current directory”, searches for files and/or directories that fit the requirements and if it finds any, lists their contents to the user on the following line. If it cannot find any, the terminal will tell the user that there are no files or directories that fit the description given.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=12186eeecc68" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[This age of information is one that not only allows for the betterment of humanity as a whole but…]]></title>
            <link>https://medium.com/@dparha012/this-age-of-information-is-one-that-not-only-allows-for-the-betterment-of-humanity-as-a-whole-but-24342c3016bb?source=rss-7d673c4e09d1------2</link>
            <guid isPermaLink="false">https://medium.com/p/24342c3016bb</guid>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Daniel Parham]]></dc:creator>
            <pubDate>Sun, 07 May 2017 22:09:43 GMT</pubDate>
            <atom:updated>2017-05-07T22:09:43.114Z</atom:updated>
            <content:encoded><![CDATA[<p>This age of information is one that not only allows for the betterment of humanity as a whole but also provides the individual to have access to multiple ways of self-improvement. The idea that someone can change their skillset such that they can be on the front lines of technology and effectively the changing of society is made possible by software engineers. Creating applications for social uses to writing software running the banking systems of the world the ability to program computers and utilize their ever growing power is becoming more and more important to the way we choose to live our lives and progress through time. Rightfully so these creative and hard-working people are compensated generously in hopes to, among other things, invite more to enter the field. With cars, planes, and all sorts of vital tools used everyday requiring millions of lines of code that fact that what has been accomplished has been done so by a dedicated few is exciting in that if more were to embark on understanding the different programming languages and applying said knowledge the possibilities of technological advancement seem limited only by our imaginations and the laws of physics themselves. If attending Holberton, a school that is focused on helping those who wish to become software engineers, is the way to become a part this community then I am in. The experienced group of instructors, the emphasis on how one learns, and the inclusion of an internship is enough for an education from this institution to be seen as extremely valuable. In addition, the lack of required upfront tuition makes it a practical choice to jumpstart a career in arguably one of the most lucrative and influential sectors in the American economy</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=24342c3016bb" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>