Since I returned to blogging, this isn’t the first time I’ve had this problem. In fact, it’s the third–which, for a site that’s had four new blog posts (one of which won’t see the light of day, at least not here) since I returned–is absolutely abysmal.

Originally, I assumed the problem had to do with using Word’s blogging plugin–something I tried on the first post. I didn’t copy/paste in from Word (which I know has been troublesome for a lot of people), mind you–I used their built in blogging features. Still, WordPress refused to let me schedule the post (in fact, that particular post still can’t be edited–I found a workaround to publish, but I can’t edit or tag it without causing WordPress to hang).

Fair enough, I thought. So the next article I did, I typed in manually. Again I had troubles, but this time I found the offending segment and fixed it. Annoying, but not horrible. WordPress, for some unknown reason, made me change my wording; oh well.

And the third article I did went without problems. I was hopeful that everything had been cleared up.

Not so. Not even close. This last article hates me for two quotes I put at the beginning of the article, both of which are essential to the article, without which the article doesn’t make sense, and which can’t be modified, because, well, they are quotes. And yes, I’ve tried deleting and retyping them. I’ve tried manually editing the HTML code instead of messing around with the WYSIWYG editor. I’ve tried everything–nothing works except removing the offending quotes.

So I don’t care if there is an explanation (though I would like one). I don’t care if WordPress has some sort of reason for not being able to accept my input. I’m done with this service. Back when I originally started using it, I thought it was fantastic (I had just moved over from Blogger). I don’t know where I’m going next, but I can tell you I won’t be staying. I gave WordPress a lot of chances, because I really do love the administrative features and interface. The point of a blogging service is to help the user publish their words–not to require them to change their words around and mess around with their paragraph order for a few hours trying to make a post. It’s already enough work to write these posts. I’m not going to spend more time then I need to getting them to work.

Goodbye, WordPress.

Of course, college schedules happen to differ a lot from the high school/summer norm—instead of having classes 9-3 every day, I’ll have entire blocks of time in the middle of the day with nothing, then my loathed 5-7PM or 7-9PM night classes. And yet, it is still a schedule; maybe not as easy to make routine, but still something that stays rather constant.

The issue isn’t that the classes don’t repeat—it’s that every day offers different opportunities and no two club meetings or tech talks or moments spent hanging out ever are quite the same. And the lesson to be learned from all of this—if there even is one (and there doesn’t always have to be)—is that repetition is evil. Doing the same thing over and over is boring and more importantly distracts from what we actually should be doing—constantly learning, growing, exploring, solving, and finding interesting problems. But is boring repetition unavoidable?

Most of the education system seems to be designed around the idea that yes, repetition is both necessary to learning and an unavoidable aspect of adult life. In high school ideas in STEM classes are reinforced by problem sets; for some reason, prevalent wisdom among mathematical and scientific educators is that doing the same thing over and over ultimately drills it into our minds. In theory, it makes sense that practicing a single technique or method will make someone strong at it; in practice, someone who understands the first problem probably doesn’t really care what the answer to the 50th is.

This ideology of repeating one aspect and then moving on to the next has its clear drawbacks. The most obvious flaw in the methodology is that anyone who has difficulty doing the early problems is likely to altogether give up when they arrive at the later ones. Of course, educators tend to argue that it is difficult to teach people who “don’t want to learn,” but how do we make someone want to learn when the only reason we give them for knowing algebra is being able to solve the 50 boring problems siting in front of them right now? Even if they do master the subject material, there is no solid reason to remember it (other than the already antithetical “you’ll need to build on it for next year’s class”).

The solution isn’t story problems by the way—usually they are just as one dimensional and boring as the other problems. Story problems aren’t there to make math or science more interesting, they are there to see that you can conceptually analyze a problem in addition to being able to numerically solve. Why would anyone care how many apples Sally had left any more than they would care what x is equal to in the equation 3x-7=11?

Another flaw less obvious but still prevalent in the “repetitive enforcement” methodology is the idea that each concept presented must be small and build upon the last. The idea that there is an inherent “order” in some fields or concepts leads to, for example, the first lesson in most introductory physics courses being vectors—something essential in analyzing complex problems but completely uninteresting without kinematic descriptors and dynamic laws for them to interact with. In the same vain, we insist on course orders knowing full well that every single course actually overlaps. Trig is essential to calculus but how many students who haven’t actually taken calculus actually understand where e comes from? Chemical reactions at a molecular level are best explained by physics; biological processes on a small scale are best explained in chemical terms; biological processes on a large scale may be described in sociological or psychological terms; statistics takes many of its essential derivations from calculus; even basic algebra includes elements of set theory and number theory.

There is no good reason for us to approach every single field this way. We insist on isolating the way fields are taught in high school when we can’t even isolate the fields ourselves. We teach physics late because we think high level math (trig, calculus) is essential to understanding, yet we teach chemistry before physics when we know that thermal and chemical physics are essential to our understanding of chemistry. More importantly, no one will bother to learn when they aren’t working on something interesting—even the most talented minds are wasted on problem sets because there isn’t a single good reason a problem set presents for a student to want to learn. Isn’t the most critical element of the education system that we understand concepts—not only how they work, but why?

We do need to reinforce ideas, build upon what has come before, and provide some sort of division and order to classes (after all, K-6 science education is nearly worthless thanks to no clear learning objective in the science system). We just need to do this in a constructive manner. Repetition is boring and will turn students off of homework or even entire fields altogether—social studies education, which at the high school level pivots around students actively discussing, debating, and deconstructing topics with the ultimate goal of putting them back together and building something new, tends to be much more successful in imparting ideas then STEM classes do, even though there isn’t really any good reason microeconomics should be easier than calculus. Already, educational programs exist which attempt to do this in STEM (programs like IMP and physics classes structured around introducing kinematics and dynamics conceptually before introducing mathematical analysis)—but the complaints leveled at these programs tend to be that they “fail to prepare students.”

Fail to prepare them for what? More repetition? Our problem isn’t backwards compatibility—we need to revamp the system in order to make it work. Repetition may in fact be necessarily every once in a while, but even in adult life the tasks that present themselves differ from day to day. At a minimum, we can’t just keep repeating the same thing over and over. We need to be more creative—maybe then our students can be.

I won’t be covering the suit itself in any more depth–after all, media outlets have that handled. Instead, I want to focus on the application of intellectual property laws to the digital age.

Intellectual property laws were developed originally to protect the creators of ideas from having these ideas stolen. The idea of intellectual property claims including copyrights, patents, and trademarks have existed for a while, but the common practice of having the majority of a company’s assets rooted in intellectual property claims was not commonplace until the latter half of the last century–evolving specifically around the same time as digital property and media laws began to emerge.

Of course, the usage of intellectual property laws and other usage laws has changed with the advent of modern digital media. Consider the End-User License Agreement (EULA)–the statement that everyone clicks “I Agree” to when installing software. The idea behind the EULA is that the company has not sold you its software, but instead a license which allows you to use the software–all the while restricting your usage of the software. The concept of the EULA is completely foreign to most other industries–you are never sold a car which has its hood sodded down, disallows you from letting a friend borrow it, and requires you to fill it up with gas from the company that sold it to you–but then again, most industries are not operating on the same unique principles as the software industry. The EULA was conceived to protect the developer–while most physical products are not duplicable, software can be copied, shared, and spread without problem if not for the legality of the EULA (and the enforcement of copy protection techniques such as product keys and online activations).

However, the modern usage of the EULA governs much more than that. They tell us what we can do with the product (e.g. limiting us to educational usages or preventing us from installing it on multiple computers, even if only for one person’s usage). EULAs are everywhere and affect every product (even those in the open-source domain, though in order to be considered open-source the license must follow a set of rules which disallow the same obscene restrictions that exist in most proprietary software from being placed on it)–even programming languages like Java can have an EULA through the JDK and JRE (which has several strange provisions–including one preventing programmers from using Java in nuclear applications).

The result becomes that the EULA exists now not to protect the developer but to restrict the consumer. Returning to the example of the car, now imagine being sold a car where not only are you given restrictions on what you can do and who can use it, but also restrictions on your usage of it–not being allowed to drive it certain places, for example, or having a restriction preventing you from travelling faster than 100 mph, even if it is well within the capability of the car to do so. Why, exactly, must a restriction be placed on Java disallowing it from being used in nuclear power plants? What–other than the extremely specific paranoia of the publishers–justifies this kind of restriction? Modern nuclear power plants, after all, need software–all this forces a developer to do is find another language to build the software in.

The issue arises when we consider just where the boundaries of such restrictions should lie–something that hasn’t yet been defined, legally. Can a developer, for example, restrict the usage of a program based on their own beliefs or morals. Can an EULA specify, for example, that a program is not to be used in an election campaign unless for a candidate of the developer’s preferred political party, or that it cannot be used to develop software that competes with other products made by the developer?

The obvious truth is that these types of provisions corrupt the purpose of the EULA to protect the developers–which returns to the original news story regarding the lawsuit. While many people regard free software and open-source as the war of the small individual-run projects against large companies and conglomerates, this is clearly not the case. Large companies have just as much right to protection as the small companies–and ultimately, no company, organization, individual, or government entity should be able to restrict the developments and advancements of another. The free market thrives on competition–but in the digital world, many seem quick to make attacks based on ideas. The Interval Licensing lawsuit is not the only such example–consider Apple’s lawsuit on Android products using multitouch technology (something Apple holds the patent on but did not develop the technology behind), or SCO’s lawsuit against IBM and Novell regarding code patents being used in Linux.

Imagine where the world would be if this type of intellectual property bickering had hindered all developments. What if the transistor patent had been used to prevent the usage of the transistor in devices other than th’ose made by AT&T Bell Labs? Despite claims to the contrary in AT&T’s 1993 You Will” series of commercials (below), most of the innovations of the last 50 years haven’t been developed at Bell Labs (and nothing shown in the commercials was either). A monopoly on modern technology would exist if the patent had been used in this way–and even so, we still would be further behind in technology.

Modern technical development thrives on competition and innovation. Who has the idea is unimportant and it should remain that way–it is all about developing the idea, showing the applications of it, and allowing your ideas to become something more. Imagine if Motorola was paying royalties to Gene Roddenberry (the creator of Star Trek) for making cell phones. Imagine if Google, the world’s largest search engine, didn’t exist because Yahoo had prevented them from creating another search engine.

Intellectual property law no longer serves to protect the creators of technology. It now corrupts and destroys the creation of technology. Sure, Interval Licensing doesn’t actually make any products, but that doesn’t make it right to be used by companies that have developed the things their patents cover. It allows companies like Amazon to charge others for using the idea One-Click shopping–while Amazon did in fact develop this idea, restricting others from copying it is outrageous. After all, imagine if only one bank offered ATM services, if only one printer manufacturer used color ink, if only one electronics company made color TVs. Competition is not only important in pricing–it forces innovation which IP laws are now actively preventing.

So whereas an EULA restricts the consumer’s usage of the software, an intellectual property claim restricts the company’s usage of the idea. Tactics like these are being used by companies which are afraid to face the fact that the digital age introduces a new type of industry and a new type of resource–information–and that the old techniques of controlling products and services are inapplicable. Instead of arguing over intellectual property in a courtroom, companies need to return to the drawing board and rethink the way they do business. In fact, we need to rethink the way we do business. Innovation is built upon the ideas of others, and it is ultimately inevitable that the future of the computing industry lies in the hands of those building tomorrow’s companies.

1. This is the first post on my blog in nearly a year of inactivity.

2. A couple changes like the deletion of categories and the relabeling of tags have been made, and all the old posts have been archived.

3. This is probably my third apology for not posting more.

I’ll begin with an update on the last year. I’ve graduated high school and I am now a student at the University of Illinois at Urbana-Champaign, majoring in Computer Science. I just moved in, and as the post schedule dictates (new post every Monday at 9:00 AM), anyone who jumped on the ball and noticed the new post will be reading this right as I start my first class.

Of course, there aren’t any regular readers of the blog because there aren’t any regular updates (two things that are about to change, and I promise this time). Anyone reading this is probably just someone who follows me on Twitter or a friend on Facebook—assuming I got those updates to work as well.

Even though I’ve just moved into college, I realized something—there is not, ever, a fresh start in life. That’s not to say we can’t make changes, but simply having everything we once had go away would destroy who we are as a person. College offers the opportunities that look like a fresh start: a brand new life on your own, complete freedom, etc. The catch is that there is a lot more to it than simply telling yourself you are going to start over. Just repeating it and letting old habits set in again is the reason people often give up on New Year’s resolutions, the reason people have trouble quitting an addictive habit like smoking or drinking, and the reason that so many attempts to do something new go by the wayside.

Of course, we forget that a fresh start isn’t actually what we are looking for anyway. Our past experienced—positive or negative—define us in many ways. What college does provide is a chance to reboot—to change things and refresh ideas and habits while still keeping the underlying personality. As a result, I’m rebooting this blog. The old posts aren’t gone—you can still find them—but there is no need to read them if you don’t want to. The blog’s theme remains the same: exploring technology and the hacker subculture (and the definition of the word hacker remains the same—people asking how to break in to systems aren’t listening and should read the about page).

However, in making these changes I realized something else: it is impossible to hierarchically organize most things. After all, life is complicated and messy. It isn’t impossible to organize, but the ways we are used to doing it are constantly changing. Not everything fits perfectly into one little box on a form. We live in an age where we can rethink how we organize—an age of using labels on your Gmail conversations instead of sorting single messages into Eudora folders. As a result, I’m forgoing the categories system and the old tag system I used in favor of a tag system that explains what a post is about (not what it mentions). This post is tagged “introduction,” but it’s not tagged “college” or “hacking” even though I mention those things because it’s not about those things (and it’s not tagged “post” because that would be way too general). All of the old posts that are archived now are gone from the tag system. Like I said, I’m not deleting the posts—they remain for anyone to read. They just aren’t the main part of this blog anymore, and as such, I’ve archived them and won’t be re-organizing them.

So welcome to the new Hacker Hideout. There will be a new post every Monday at 9:00 AM, and if that works out, maybe more often. I look forward to sharing my technological experiences and hope that you will stick around to listen—it’s going to be a fun trip.

Of course, three is an oversimplification most of the time. There aren’t actually three branches of US Government (bureaucracy is the fourth branch, the media is the unofficial fifth branch, and let’s not forget various inputs and factors and federal and state governments, etc—you didn’t think that having classes on political science was pointless, now, did you?), but we still divide it into three branches because it’s simple, and makes the most sense for checks and balances and separation of powers and the like. And, while it may not be immediately obvious, we kind of divide hacking/technology into three separate fields as well: Computer Science, Computer and Electrical Engineering, and Information Technology and Sciences.

“But wait,” I hear you say. “Hacking is about programming. That’s computer science, right?” (By the way, if you still need a primer on hacking, see my about page and the websites I link to. Hacking ≠ cracking).  This might very well be accurate, but programming is no longer limited to computer science. From application programming and database programming to complex AI constructs and NP-complete algorithmic structures to HDLs (hardware description languages) and Prolog (logic programming), it has become impossible to argue that programming is a specific field of computing. Programming is now the core tool which all computer technology is centered around.

So, what is modern computing about? How do we decide whether to major in Computer Science or Computer Engineering or Software Engineering or Electrical Engineering or Information Technology and so forth? How do we determine where we want to work, and what we want to do? Knowing that you’re interested in computers and programming simply isn’t enough anymore.

The new challenge is exploring all fields of computing technology and their applications. The hacking community places a strong emphasis on education, be it self-taught or otherwise. The key to educating yourself on various technology topics is knowing what to look for and how to find it.

I believe that the absolute best method of education in these circumstances is to learn by doing. The graphic below shows some basic technology tasks on a three-pronged spectrum, illustrating (somewhat poorly) where different tasks fall along the lines of technology and understanding. The encouragement is there, though: set up a server, design a program, design a circuit, read about various search algorithms. The challenge is not to master everything, but to find your own interests.

Three Branches of Hacking with Associated Tasks

One final word to the wise. The world of hacking is a vast expanse filled with tons of fascinating things, and a huge part of the attitude is finding interesting problems and challenging yourself at tasks you find fascinating. Don’t be surprised if the world completely absorbs you and leaves you surrounded by technology with no way out, and don’t worry if this search makes you even less sure of what you want to do with computers and even more interested in them. The truth is for those who are interested by computers, the world is filled with tools to explore them and get lost in them. Whether that’s a good thing or a bad thing just depends on how much time you have. Oh, and don’t feel alone in this endeavor. Expect next week’s post to go even further into this, perhaps beginning a basic tutorial to exploring computers through programming or something similar.

I set off to write a blog in the same vain of an explorer or adventurer: without any clear sense of direction or idea, just a slight picture of a possible destination and a few ideas on how to get there. In the past few days, it has become increasingly clear to me that with college applications, homework, journalism, scouts, and so forth, it may be impossible for me to continue. So I began (again) to ponder why we blog, and realized that it is more than an extension of ourselves; it is a hope, however brief, to inspire, educate, and share. Blogging is a mutual learning experience, one in which the readers expect to learn from the blogger, and the blogger expects to learn both from the readers and his or her own posts.

In this last week I discovered two things: 1, that I cannot possibly keep posting regularly without interfering with everything else I need to do, and 2, that I cannot possibly stop posting. So, from this point on, I promise to update my blog (at least) once a week, on Mondays at 9:00 AM CST (I’m setting the timer for this, I’m usually in classes at this time and as such actually writing my post right before the deadline would be impossible).

Expect the next post this Monday, at exactly 9:00 AM CST. I have four topics I’m working on, so from this point forth, I’m expecting uninturrupted weekly posts.

Have a great weekend! Looking forward to an exciting year.

Don’t worry though, since this particular post isn’t going to focus on college applications. It just happens to turn out that the poor design of a college list is a good analogy for code optimization. A bit of background first though. The average amateur programmer knows what code optimization is but doesn’t consider it important to them or their code. Until Project Euler, I was the same way. Project Euler, for those who don’t know, is a mathematics and programming challenge which presents relatively simply mathematical concepts (which get more complex as the problems do), and challenges a user to solve them. There is no need to use a specific programming language, or for that matter even to use a programming language, though most of the problems require it. In addition to being a great way to learn to program or refine programming skills, it is also a very fun challenge.

In order to not spoil the fun of solving the more advanced problems here, I’m discussing Problem #3. I’m not posting the answer, but I am discussing source code and optimization methods, so have a crack at it yourself if you want before reading on.

Problem #3 involves prime numbers, so it is useful to begin by reviewing the prime number rules briefly.

• Prime Number: A natural number whose only distinct natural factors are 1 and itself.
• Composite Number: A positive integer which has at least one positive factor other than 1 or itself.
• 1 is neither a prime nor composite number.
• Any composite number can be broken down into key prime factors. For example, 6 is 2*3, and 150 is 2*3*5*5.
• When searching for prime factors, we don’t care about the exponents. So while 150′s prime factorization is 2*3*5^2, it’s prime factors are simply 2, 3, and 5.

That might be even more information then necessary for this problem, but it is basic prime factor information and pretty light mathematically, so it’s good to cover here. Next up, some simple programming terms I’ll be using throughout this post:

• Programming Language: A format for writing source code, which is interpreted or compiled by the computer
• Algorithm: A method of doing something using an instruction sequence. Not limited to computer science in this definition, stretches as far as psychology.
• Efficiency: A measure of how quickly and simply an algorithm runs when scaled
• Brute-Force Algorithm: An algorithm in computer science which involves trying every possible solution to determine if it is correct. It is not necessarily the least efficient method, though it is often less efficient then other algorithms.

The programming language I’m using to solve this problem is Python, which I’ve mentioned before. Python is an easy-to-use programming language that can be learned quickly but applied to many advanced tasks, and it’s also the most common reported language used on Project Euler problems. I’ll explain my code, but since Python emphasizes code readability, it should make sense.

Okay, so finally, on to Problem #3. The problem asks to find the largest prime factor of the number 600851475143. Finding prime factors would involve breaking down the problem into two simple components: generating prime numbers and finding prime factors for a composite number.

The brute force method for finding prime numbers is taking a number, dividing it by every lower number except 1, and returning true if no numbers divide evenly into it. We continue to cycle through prime numbers until an exit condition is met, such as having found all primes below a given limit or having found the next prime in a sequence.

For this problem, the brute-force method of finding primes is sufficient and in fact should function rapidly. I may revisit this later to discuss more advanced mathematical ways of finding primes, including using a Sieve of Eratosthenes for a given upper bound, though the math behind that is a bit more complex then I intend this post to be. So, here is the code for the simple prime number generator using the brute force method:

# nextPrimen>(n) finds the next prime after n
def nextPrime(n):
    val = n + 1
    while(True):
        # Check if val (n + 1) is a prime
        if checkPrime(val):
            return val
        else:
            val = val + 1

# checkPrime(n) returns true if n is a prime number
def checkPrime(n):
    x = 2
    while(x < n):
        if n % x == 0:
            # Factor other then 1 or n, number is composite
            return False
        x = x +1
    # Number is prime, while loop terminated without finding factor
    return True

This code should be pretty straight-forward, and it’s clearly a brute-force algorithm for generating primes. For the prime factor finder method though, the brute force algorithm involves dividing the number n by every prime below it. Since we’ve already spent a lot of time on finding the primes, checking every single prime number would be ridiculous and take forever. So we need to find a faster way to do it.

This is where optimization steps in, and where Project Euler begins to challenge the problem-solver to think outside of the box. The brute-force solutions are simple and straightforward, but for the large values in problems, such as 600851475143, the brute-force algorithm would take a long time to complete. Project Euler states that any of their problems can be simply solved by the computer in under a minute (that is, that while creating the program may take hours or even days of planning and thinking and writing, the code itself should execute in under a minute). As hackers working on an easy problem, we also understand that the most elegant solution is one which is both efficient and simple.

Finding the more optimized solution requires thought and consideration as to how efficient the solution will be. In computer science, algorithmic efficiency is often expressed using Big-O Notation, where the order of the algorithm is expressed in terms of n, n being the number that will be scaled in the problem. It is important before using Big-O Notation to know what n actually represents. In a server program, it might represent number of users, for example. It is always some value we expect to scale, though. In our case, n is the constant we have to break down: 600851475143. The constant they broke down for us is 13195, which when compared to 600851475143 is a very low number. So an efficient algorithm should not take a huge amount longer to check 600851475143 then it does 13195.

I won’t show detailed Big-O Notation, better to save that for another day. However, it can basically be broken down as a way of describing how a given algorithm scales. Linear order would increase by a constant amount as n increases, for example, while exponential order would increase rapidly as n got larger and larger, and logarithmic order would increase slowly over large changes in n. Constant order would not be affected by the value of n, such that the time to process a small n would be the same as the time to process a large n. We already know that our brute force algorithm also has to take into account the brute force algorithm used by our prime generator, which is of a quadratic order—not perfect, but fine for now. Checking every prime below n would take a while, so it’s time to start brainstorming some ways to improve our method.

First, there is a rule that for any number n, the only prime factor greater than the square root of n is n, or in other words, all prime factors other than the number itself are below the square root of that number. This could be used to our advantage, but all it does is change what n is, not the efficiency of the code (meaning for very large numbers like ours, even though the square root is much lower, the code still won’t run fast enough).  When stuck behind an optimization problem, often the best thing to do is discuss the program efficiency with someone else. I discussed this program with Jonathan at The Twilight Sun (see my sidebar), and we decided that the best method would be to constantly break down the number while processing it:

# Returns prime factors of n. Returns an empty list if n is prime.
def factors(n):
    factorList = []
    prime = 1
    while (nextPrime(prime) <= n):
        while n % nextPrime(prime) == 0:
            n = n / nextPrime(prime)
            factorList.append(nextPrime(prime))
        prime = nextPrime(prime)
    return factorList

I know that this code is a lot less self-explanatory then my earlier code, but it should still seem pretty simple. Every time we find a prime factor of n, we divide n by that prime factor, and start looking for the prime factors of this new, divided number. So, with our example prime of 13195, it will find the factor 5 and n becomes 2639 (13195/5). The while loop repeats over the same prime (note that we haven’t changed the starting prime yet, and therefore haven’t changed the number we are dividing by) to try and break it down even further, which will fail because 2639 does not divide into 5 evenly (without a remainder). Now it continues with n as 2639 and finds that 7 works, making n 377. The next functional value is 13, which makes n 29, which is our final prime factor.

We will always end with our greatest prime factor, so we could just return the new n. What’s more, we can even further optimize this problem by throwing in the square root rule, which works to get us n even faster. So here is the final, super-optimized greatest factor finder.

import math
# Prime Factor Generator Code is above
# Returns greatest prime factor of n, other then n itself.
def greatestPrime(n):
    prime = 1
    while (nextPrime(prime) <= math.sqrt(n)):
        while n % nextPrime(prime) == 0:
            n = n / nextPrime(prime)
        prime = nextPrime(prime)
    return n

As expected, this code calculates greatestPrime(600851475143) super fast. However, it is important to note that the final value will have an ‘L’ at the end of it. This is Python’s way of informing us that the value is stored as a long number. Even though our final value isn’t a huge number, the value we started with (600851475143) is too big to be stored as a simple integer. Python handles the data type for us (dynamic typing) but doesn’t change it (strong typing).

Some final closing notes regarding both this problem and the blog. First off, this post was way longer then I would have liked, so I expect to be doing shorter posts in the future, and breaking long topics like code optimization down a bit. Second, I am aware that I could use a library for prime number generation, and I’m sure the library code is more elegant than mine. I opted not to here in order to best demonstrate the process without using libraries, and I recommend others going through Project Euler keep this advice in mind: while it is true that one hacker mantra is that no problem should be solved more than once, it is also important that before using someone else’s code you fully understand how and why it works, even if you could not have developed it on your own. In this way, you learn to read and write code, and not simply to use the tools available but to understand how they work. Finally, I used while loops everywhere, including some places where for loops seemed to make more sense. A for loop in most languages is a while loop given three statements, one the standard conditional of the while loop, another the initial value for a variable in the while loop, and the third an increment or operation to be performed at its completion. Python does not use for loops in this way: instead they parse through a list of values, thereby serving a function which cannot be emulated with while loops, sticking with the Python ideal of having only one right way to do something. While for loops can be used like one would expect with the range() function, I felt that using a while loop made more sense in terms of memory.

So again, I plan to make this shorter next time. Hope you learned something!

For anyone keeping track, this is my third post. I made the first one in May, the second in July, and here it is, (barely still) September. One post every two months, and perhaps a few page views here and there. It’s not working. I wanted to figure out what I needed to do to make a blog, and in the process, I realized why so many blogs die: our thoughts are publicly expressed online, and the worry that they might appear wrong or inaccurate ultimately causes the deterioration of the blog.

For me, it was organization. Appendix B of the Jargon File (a recommended read for anyone remotely interested in this blog) states, “they tend to be careful and orderly in their intellectual lives and chaotic elsewhere. Their code will be beautiful, even if their desks are buried in 3 feet of crap.” However, what it does not mention is that human thought is, by nature, chaotic. Often we lack the words to express an idea, and even when we can form them, our brain presents the idea to us long before the words. There is no chicken and egg style debate here—the idea must proceed the words used to describe it.

The difficulty of creating a blog is therefore obvious—the blog is created before all the ideas that will go into it are even formulated. One of the first tasks I set myself to was creating categories, a seemingly simple task. My lack of simple categories lead to a three page word document, several layers of nesting, and ultimately nothing worthwhile but a failed and confusing system, and only two posts even using it. Rereading my posts, I realized that my original categories sucked because they didn’t describe the general attitude of the post, but rather any topic I even briefly mentioned. This was a task much better suited to tags, and upon returning to my blog tonight, I immediately threw out all my old categories and started anew. The result was a much better system, with three broad categories (Technology, Hacker Culture, and Personal) and space to allow me to add subcategories as my blog (and my ideas) grew.

Most importantly, though, is what I learned from this whole ordeal. In order to express one’s self, you must throw out structure, and begin from scratch. The framework does not define the building, rather each individual brick eventually defines the framework. This is the world of blogging, the world I foolishly decided to enter more then four months ago, and the world I am only now truly ready to enter.

So, I hope someone’s listening, but I don’t honestly care right now. A blog is an explosion of one’s mind onto the nearest available canvas: it is like any other art. And while others may enjoy our art, and we as artists may nod our heads and say that’s why we created it, it’s honestly not. We express ourselves, for ourselves, perhaps foolishly hoping someone’s out there searching for themselves too. This is my expression, this is my mission and purpose, and most importantly: this is where my blog genuinely begins.

So, on to what I actually meant to talk about (I’ll cover some of the other stuff I mentioned in later posts). Being at camp has many benefits, and I love every single thing about it, from watching the morning sunrise over the staff row to swimming in the lake to simply sitting in my cabin during downtime and relaxing, perhaps playing cards with a few friends or doing a bit of writing. Of course, I have a lot of work to do, and I’m a dedicated staffer, but what’s important to me about the experience is that regardless of the type of personality the job attracts or the constant proximity to my work, I maintain a sense of identity, and let the unique aspects of my personality present themselves.

Identity. How we define our identity was a major point of my last (and first, and only) post, and it’s brought up on my About page as well. Who are we, and what makes each of us different from the next individual, and so forth: questions we may not ask ourselves every day, but certainly the questions from which all others we have stem, from all actions we take and words we speak come. How we identify ourselves is not just an important thing; it is the most important thing. After all, without identifying ourselves, how can we identify anything else?

I was working recently on a final project for my AP Computer Science class. The project I designed involved using the Google App Engine to create a credentials manager of sorts, which stored usernames and passwords for different websites. Relatively simple, but a fun app to code nonetheless. What we generally define ourselves by on the internet doesn’t generally go much further then a few basic pieces of data. Consider this: on most forums, all you can know a user by is their username and avatar. Maybe you can click on their name and a few loosely defined fields they filled out pop up: interests, hobbies, profession, and so forth. As a result, the more one uses the internet, the more sites the register for, and resultantly, the easier it becomes to have a predefined list of interests, hobbies, etc.

The problem presents itself when we consider that beyond this, most people have difficulties defining their identity. Personality, like so many other attributes of humanity, cannot be described by simple words. It is my belief that a person could not describe their entire personality using an extensive vocabulary and stellar writing skills, even by writing volumes of information on the subject. If we were to take every written work of a person, every thing they ever put on paper, we would still only have a single dimension of their personality. Sure, what we could obtain from this would be an immense load of data on this person, but only in a single context. Therefore, always remember that despite the many forms of expression and the many survey-like questions developed to mark one’s identity, only you can truly understand your identity, and defining that should be not a constantly present objective but an underlying element of your life, always present but rarely in conscious thought.

PS: I’ve been trapped by working at camp. Posts will be scarce this summer.

Hello to everyone reading my blog, and anyone who’s insane enough to go back in the history and try to read every single post!

First, a bit about myself. My name is Dylan Nugent, and I’m a high school student. If the title and subtitle of this blog didn’t make it clear, I like programming, technology, and the open source/free software ideologies. I also love nature: I’m a Boy Scout, I camp at least once a month, my summer job is as a camp councilor, and I’ve climbed to 11,695 ft on Mt. Phillips at Philmont Scout Ranch in Cimmaron, NM. When I’m not programming or camping or doing homework, I’m probably practicing piano or guitar, working on writing something (be it a song, story, poem, etc), or reading. I don’t have a favorite subject because I love pretty much every subject (though my APs – Computer Science, Psychology, and Statistics – top the list). Most of my extracurriculars lie in Boy Scouts – I’m the Owasippe Lodge Treasurer for the Order of the Arrow and my troop’s Assistant Senior Patrol Leader – but I also am a part of my school’s Journalism team and take music lessons, among other things.

So, a bit about this blog. The title is “Hacker Hideout,” and for those who didn’t understand, that’s hacker as in someone who creatively tinkers with technology, enjoys coding, and believes in certain principles, and not a cracker, someone who illegally breaks into computers. Eric S. Raymond’s article, “How To Become a Hacker,” is a good starting point for those who don’t understand.

Great, right? I just started what has to be the elevendy-billionth technology blog on the planet, right? What makes my blog special isn’t the “Technology”, it’s the “Everything After.” I mentioned before a vast diversity of activities I participate in. Giving up all technology for three weeks to go spend time in the wilderness backcountry may seem atypical of a computer nerd or geek, and that’s because it is, to an extent. Being a hacker is about a lot more than just an affinity and interest for tech. My blog is about tech and being a hacker, sure, but it is also about living life to its fullest extent, enjoying yourself, and finding your passion.

So welcome to Hacker Hideout. I’m sure this blog will grow and become more defined in time, but for now it’s pretty much about anything I think of. I look forward to the feedback! (Keep in mind a general rule for feedback though: if it’s spam, inappropriate, or highly offensive to anyone, it gets deleted. I appreciate criticism and won’t censor it, including the “this guy sucks” post, but anything with a lot of swear words or offensive language will most likely be deleted, if not at least censored).

-Dylan Nugent