Building a Plone 3 Product Pt.1: Archetypes
Apr0
If you’re reading this, you probably know what Plone is. A Content Management System based off of the Zope framework and written in Python. You’ve probably set up your own instance, installed a product or two, maybe even added your own external method. Well now you want more. You want to be able to customize your Plone instance and make into exactly what you want it to. That’s the journey we’re starting on today. We’re going to make a basic product that contains a content type for books.
Note: This tutorial is pretty much identical to the tutorial done by Christopher Warner. The reason I made this is one is because I plan on explaining more about Plone, and this is a good starting point. Please visit his blog as well.
Using Paster
Start by going to the /src directory of your Plone instance. When making new products, it’s standard to put all the products your developing here.
While you’re in the directory, you’ll need to use paster to generate all the basic files in a product:
paster create -t archetype
If you don’t have paster, install it now:
easy_install PasteScript
Paster is the best friend you could ask for when it comes to making new Products. Paster has several different templates built in (you can see a list using “paster create -t list-template”) that you can use to generate templates for all kind of Plone-related products and instances. For today though, we’ll be using the “archetype” template.
The Archetype template generates code that you’ll want for a product that extends the “Archetypes” product in Plone. The Archetypes product is there for only one reason: as a provider of schemas that we can use to make new content types quickly. This makes it an ideal choice for our project today.
When you run the script it’ll ask you a lot of questions. Let’s talk a little bit about what each of them are about:
- project name: This name should reflect what your project is for. This will determine the name of the egg, package, and project, so keep it short. One word is good.
- Project Title: This name should reflect what your product is for. A one or two word title would be good
- Namespace Package Name: This is the namespace that you want your content to be a part of. If you have a group of products you want to be related to each other, they should all have the same namespaces. However, it doesn’t really matter for the most part. Most people just use “Products”.
- Package name: this name should describe your product. When people look at your product, they’re going to see this and the Namespace Package name. For example, if my namespace package name is “Products”, and the package name is “books”, they’re going to see your product as “Products.books”.
- Version: version of your product, generally 1.0.
- Description: a short, one sentence description of your product.
- Long Description: a longer description of your product.
- Author: your name, usually. Possibly your company’s name.
- Author Email: your e-mail.
- Keywords: You’ll want to fill this out so people can find your product. If it’s just for that once instance, it’s not as important.
- Project URL: URL to the product’s main page.
- Project License: The license you want your project to be released under.
- Zip-Safe: Generally I would leave this as false. If your project is usable as a zipped egg, put true. But generally, putting False is staying on the safe side.
For this tutorial, fill it out with these entries:
Project Name: books
At this point you’ll be prompted for an easy, advanced or all install. For this tutorial, you can just choose easy.
Project Title: Books Content
Version: 1.0
Description: Contains Contenttypes to represent books.
after you fill out all the necessary fields, paster will generate a folder containing the basic files needed.
At this point, you also want to go into configure.zcml and remove the line talking about locales. We will not need it for this part of the tutorial.
Using Paster for Content
At this point, you should now have a folder called “books” in /src. Now navigate into the books/books/books/ directory, as that will be the main directory you’ll be working in. You’ll know you’re in the right place when you see a “configure.zcml” file, as well as a few other folders, such as “browser” and “contents”.
Once you know you’re in the right directory, you’ll use paster again, this time to add the files needed for a basic content type. Use the following:
paster addcontent contenttype
Paster can also generate other kinds of content types. You can see these with “paster addcontent -l”.
As with the previous paster command, this one also comes with it’s own questions:
- contenttype_name: The name of the content type (Books)
- contenttype_description: This is what the user will see when they look at your content type. This should describe what the content is for. It should be only one sentence (Displays and stores information about a book).
- folderish: put true if you want your content type to be a like a folder (it can hold other content types) In our case, we’ll put false.
- global_allow: means that it can be put anywhere on the site. Generally, and for this tutorial, put true.
- allow_discussion: if you put in true here, this basically puts a thread onto each instance of your content so people can discuss it if need be. Generally I would put this as true, unless you’re sure it’s unnecessary. For this tutorial, we’ll put False.
Once the script is done, we’ll can finally start coding.
Developing Content
Now that we have our basics, we’re going to start editing our books content type. Navigate into the “content” folder, and you should find a “books.py” file. Using a text editor (such as vim or emacs), modify the books.py file. You should see something almost exactly like this:
——-
“”"Definition of the Books content type
“”"
from zope.interface import implements
from Products.Archetypes import atapi
from Products.ATContentTypes.content import base
from Products.ATContentTypes.content import schemata
from books.books import booksMessageFactory as _
from books.books.interfaces import IBooks
from books.books.config import PROJECTNAME
BooksSchema = schemata.ATContentTypeSchema.copy() + atapi.Schema((
# -*- Your Archetypes field definitions here … -*-
))
# Set storage on fields copied from ATContentTypeSchema, making sure
# they work well with the python bridge properties.
BooksSchema['title'].storage = atapi.AnnotationStorage()
BooksSchema['description'].storage = atapi.AnnotationStorage()
schemata.finalizeATCTSchema(BooksSchema, moveDiscussion=False)
class Books(base.ATCTContent):
“”"Description of the Example Type”"”
implements(IBooks)
meta_type = “Books”
schema = BooksSchema
title = atapi.ATFieldProperty(‘title’)
description = atapi.ATFieldProperty(‘description’)
# -*- Your ATSchema to Python Property Bridges Here … -*-
atapi.registerType(Books, PROJECTNAME)
———–
The only important part here really is the “Books” class. At a glance, you can see that it extends the “base.ATCTContent” type. By default, this content type only contains two fields: “title” and “description”. However, we’re going to need add more fields to describe more about our books. Let’s say we need the following fields to complete our product:
1.Author
2.Publisher
3.ISBN
We can add these fields by putting them into the Archetypes field definition, between the (( )) in the BooksSchema declaration.
When adding more fields to our schema, there are two helpful resources: The Fields Reference. This gives you a good luck at the basic field types you can use to build a content type out of.
Now let’s make a new field for Author. But this into the BookSchema declaration:
atapi.StringField(
name=’bookAuthor’,
widget=atapi.StringWidget(
label=u’Book Author’,
label_msgid=’bookbook_label_bookAuthor’,
i18n_domain=’bookbook’,
maxlength=100,
size=100,
),
required=True
searchable=True
),
We gave our schema a name, and a widget that it uses to modify and view the data. If you want Plone to do automatically generate views and edit pages for you, you’re going to want it to have a widget.
Now we can do the same exact thing for the Publisher and ISBN. The formatting i for the most part the same:
atapi.StringField(
name=’bookPublisher’,
widget=atapi.IntegerWidget(
label=u”Book Publisher”,
label_msgid=’bookbook_label_bookPublisher’,
i18n_domain=’bookbook’,
),
required=False,
searchable=True),
),
atapi.StringField(
name=’bookISBN’,
widget=atapi.StringWidget(
label=u’Book ISBN’,
label_msgid=’bookbook_label_bookISBN’,
i18n_domain=’bookbook’,
maxlength=13,
size=13
),
required=False,
searchable=True
),
And there you have it. adding it all together, you’ll have something like this:
——-
“”"Definition of the Books content type
“”"
from zope.interface import implements
from Products.Archetypes import atapi
from Products.ATContentTypes.content import base
from Products.ATContentTypes.content import schemata
from books.books import booksMessageFactory as _
from books.books.interfaces import IBooks
from books.books.config import PROJECTNAME
BooksSchema = schemata.ATContentTypeSchema.copy() + atapi.Schema((
# -*- Your Archetypes field definitions here … -*-
atapi.StringField(
name=’bookAuthor’,
widget=atapi.StringWidget(
label=u’Book Author’,
label_msgid=’bookbook_label_bookAuthor’,
i18n_domain=’bookbook’,
maxlength=100,
size=100,
),
required=True
searchable=True
),
atapi.StringField(
name=’bookPublisher’,
widget=atapi.IntegerWidget(
label=u”Book Publisher”,
label_msgid=’bookbook_label_bookPublisher’,
i18n_domain=’bookbook’,
),
required=False,
searchable=True),
),
atapi.StringField(
name=’bookISBN’,
widget=atapi.StringWidget(
label=u’Book ISBN’,
label_msgid=’bookbook_label_bookISBN’,
i18n_domain=’bookbook’,
maxlength=13,
size=13
),
required=False,
searchable=True
),
))
# Set storage on fields copied from ATContentTypeSchema, making sure
# they work well with the python bridge properties.
BooksSchema['title'].storage = atapi.AnnotationStorage()
BooksSchema['description'].storage = atapi.AnnotationStorage()
schemata.finalizeATCTSchema(BooksSchema, moveDiscussion=False)
class Books(base.ATCTContent):
“”"Description of the Example Type”"”
implements(IBooks)
meta_type = “Books”
schema = BooksSchema
title = atapi.ATFieldProperty(‘title’)
description = atapi.ATFieldProperty(‘description’)
# -*- Your ATSchema to Python Property Bridges Here … -*-
atapi.registerType(Books, PROJECTNAME)
———–
Once we’ve got all the addition types tucked in nicely in the script, we just have to tell Plone to find our product so we can install it. The method we used today allows us to dynamically generate both the “view” and “edit” pages for our content type, so all we had to do was develop the schema.
Installing a Product
Now we’re on our final step: installing the product into Plone. To get Plone to see the product, you need to first add the namespace into the buildout configuraiton. In buildout.cfg (or whatever buildout configuration your using, add the following:
1.”books” (or your namespaces) into eggs.
2.”src/books” (or src/ your namespace) into develop.
3.”books.books” (or the whole name of your package) into zcml.
Once you have done all this, buildout (buildout -c buildout.cfg) and restart your instance. You should then see the “Book Content” product in your Add/Remove products, and can now add book products and modify them.
Congratulations! You have officially made your first Plone Content Type.
Go ahead and give it a try and see where your hard work got you. Next time we’ll go into a more in-depth look at the innards of a Plone product.
Why Vi is so cool… And Why you aren’t good enough at it.
Aug0
If you said that you were a master at vi, that statement alone would allow to conclude one of two things:
- You’re probably one of the best or most experienced programmers alive.
- You’re full of it.
Even If I had just met you that very second, I could already conclude as much. Why? Vi is just that difficult of a text editor to master. And people tend to think that they’ve mastered it way too quickly. In fact, I thought that I had learned most of what vi had to offer until recently, when I borrowed a book on it. After reading ten pages into it, I made the realization that most so-called pros make sooner or later: I had no idea what I was doing.
Now, as far as VI users are concerned, There are three classifications:
Beginner
So you just heard about this awesome text editor from a friend. Moving around with the hjkl keys is really foreign: why not just use the up down left right instead? I wrote code just as quickly on notepad!
Here is where a lot of people start. Generally when people pick up vi, it’s the first visual editor that they’ve used before. It’s surprising how much time is wasted just trying to get somewhere.
Intermediate
Moving around is no problem. I know how to substitute/replace. Sometimes I find there’s something I don’t know how to do, so I look it up. I see one of those crazy commands that starts with a colon, so I’ll try that out.
This is the phase I used to be at (and I’m trying to get out of). In this phase, any command involving the colon seems like a ton of crazy jargon, and you’re able to figure out a variable or two to chisel the command to doing what you want it to do.
Advanced
People like this will make fun of anyone else’s use of vi, and they have the right to. They have mastered every command vi has to offer, and use it on a fairly regular basis. Using any editor besides vi is an affront, unless of course they want to use ex.
These people have probably been using vi or ex since they were kids, back when it was the only way to do things. It’s very rare that I come across someone like this, but I can’t say I haven’t.
Most people will find themselves in the intermediate category. All of my programming jobs have been at a university, so maybe my dynamic is a little skewed. However, whenever I’ve talked to someone about vi, I can tell that their level is that of “I know enough commands to get by”.
Originally, I thought that way too. I’ve been using vi for over a year. Since I was always more concerned about making sure that code gets done, rather than learning how to use the editor efficiently. However, I began to realize that the two are combined.
vi has roughly a hundred commands. That’s not a negligible amount. At first glance, it might seem that some of these aren’t even worth remembering. But the funny thing is, it is. If you are a programmer, think about how much time you spend editing text. Think about how much time is wasted raising your hand, setting it down on the mouse, and clicking on the spot you want to move to. Or, think about the minutes that you spend copying lines of text and modifying one thing. Over the days, months, and years, you end up wasting days worth of time picking your hand up or typing repetitive code. Time that you can spend working on optimizing your code, sword-fighting with wooden swords, and doing a better job in general, the bottom line reason for learning vi is:
Because every annoying and tedious line of code that needs to be copied, or every autonomous task that needs to inserted into the code, vi can do it for you.
Copy a paragraph and put insert it into line 52? it can be done:
“ay} 52gp
In eight characters. Think about how much time your saving:
- The time it takes to copy the paragraph
- The time it takes to navigate to line 52
- The time it takes to paste it
All shortened into a second. The bottom line is, vi has so many features, it seems like an overwhelming amount of information, to the point that it may seem like it’ll save time just do these tasks manually and not worry about the shortcut. However, this cannot be farther from the truth.
If you don’t know vi, or think you know most of the commands already, take the day, week (or even weeks) to learn it completely. You’ll be amazed at your increase in efficiency, and the decrease in frustration caused by repetitive tasks.
House Jobs and The Stable Marriage Problem
Jun1
Being the steward for a fraternity has it’s ups and downs. Being appointed as one this summer, my role comes with several responsibilities: making sure everyone does their jobs, collecting money, and choosing everyone’s cleaning job for the Summer.
So let’s talk about the last responsibility: Choosing people’s jobs. Identifying this problem, there are several factors to consider:
- Everyone’s Job preference
- Who’s preference has higher priority
- The location of that person’s room relative to the location of the job.
So why is the last one important? Because people are more likely to do house jobs that affect them: cleaning a bathroom closer to you has a lot of incentive compared to cleaning one that you never use.
My love for applications of my abilities made me pose the problem in a way solvable using math and computer science. So I present the “Stable Marriage” problem.
Stable Marriage Problem
Our problem has the following backstory: Let us suppose that we have an even amount of men and women. Everyone has a preference list, ordering who they want to marry. What are the best matchups?
Of course, I don’t know what kind of people would actually create a problem like this. Seriously, what kind of person would say: “Hey, there’s four of us, there’s four of you, so let’s get hitched! But wait, we all like different people, so how are we going to decide who’s going to marry who?”
Regardless of how rediculous the problem is, here’s the way it works:
1. Start with the first guy, and see if the girl he prefers is available:
i. If she is, then pair them up!
ii. If she isn’t, then check to see if she prefers our guy more:
a. If she does, then pair them up!
b.If she doesn’t, then our guy goes on to the next girl, starting again with step 1.
2. Once the guy is paired up, we start with the next guy, repeating at step 1.
Eventually, every guy will end up with the highest-ranking girl on his list that doesn’t prefer some else who prefers her. Thus, since every guy with such a girl, everyone is more or less “happy”. Thus, the marriage are “stable”.
Now, you probably notice that we could have done the same thing for girls. The method listed above find the optimal pairing for guys: Every guy gets with who they want, but this is not necessarily true for girls. If you interchange it so that the girls get to choose, then the opposite happens: girls get who they want, and guys maybe not.
So I guess the bottom line is that there’s two ways this problem could go: Optimizing for girls or for guys. Either way though, these solutions will look very similar.
What’s this got to do with house jobs?
The hypothetical problem that you saw above is just a part of Stable Matching. That’s the official name for this particular problem. It’s just finding a Stable Match – A situation in which one object does not prefer any other object that prefers it over their current pairing.
I bet you see where I’m going here.
We essentially have two groups of equal number that must be paired up: house jobs, and the people who live in the house. It’s easy enough to get the preferences of the people: you can just ask them to give you their choice in order. But how exactly does the house job prefer one person over another?
This is where math comes in. I generated a function that will the algorithm determine the preference of a house job. Here it is:
(Distance of job from person in question)*2 + (#of that person in the queue) = priority of person to housejob.
The lower the number, the more the house jobs prefers the person. Distances in this algorithm have three levels (so integers 1,2 and 3). This is multiplied by two to increase the effect that location has on the priority due to a house job. Otherwise, the number of the person wins over.
So, a perfect example of a Stable Marriage Problem.
[EDIT] I guess due to some difficulties, our house is getting shut down. Thus, no need to code this thing. Oh well, it was fun anyway.
Shark Vs. Plane
Jun0
Today I want to learn…. Introduction to Programming II
Jun0
So want to learn more about coding? Ready for the craziest thrill ride of your life? Well, it’s not going to be that big of a deal. But If you read my previous post on programming, you should know what a program is and how it is made. So, it’s time to learn that gibberish and figure it out from there. To teach you these concepts, I’ll be showing examples in the most widely used programming language at the time of this article: C++.
Compiled Languages and Scripting Languages
All programming languages can be divided into two categories, compiled and scripting. So what’s the big difference? Well, remember when I was saying that we need a compiler to make the computer be able to execute your code? Well, the difference between these languages is when and how the code is compiled. Compiled languages, in order to be run, must be sent through a compiler and then executed. Scripting languages, on the other hand, are sent to the computer as is. The computer then has an “interpreter” built in, and “compiles” it every time it is run, on the spot. To be truthful, compile is the wrong word for scripting languages, so it is best to think like they’re being read by the computer. The best way to think about it is that for compiled languages, we need an interpreter (compiler) before the computer can read the code, and for scripting languages, the computer learns the language so it can do the instructions, just by giving it the instructions raw. Both types of languages have their own advantages and disadvantages. For the examples, we’re using a compiled language, C++.
Includes
So, we know what a compiled language is. So what’s next? Every language has a basic set of terms (also known as functions) by default. Some languages allow you to insert more terms into your program, and that is what includes consist of. C++ requires certain functions in order to act like it should. So, we need to include a list of functions, like so:
#include <iostream>
using namespace std;
as you can see, we have an <iostream>. This provides us with functions that allow us to produce actual output that users can see. as for the “using namespace std;”, this is the basic set of commands that the C++ program will understand. the “std” is short for standard. So, inserting this at the top of your file will include the iostream set of commands, as well as the standard set of commands.
The Semicolon
This is a good time to talk about one of the most vital parts of programming: the semicolon. Basically, think of the semicolon like a period; it ends your sentences and instructions
Functions
One of the things that almost all programming languages have in common is functions. A function is basically a way to package a set of instructions. So if we want our program to execute that set of instructions, we simply “call” that function. Now, for C++, we need a “main function” that the program executes when it starts. For C++, it looks something like this:
int main ()
{
//Instructions Here
}
So now we need a command, or some instruction to give the computer. One of the most standard beginning programs for a programmer to make when learning a language is called a “hello world” program. Basically, all it does is spit out “hello world”. So, let’s do that here, with the command in the iostream known as “cout”, which will basically print out whatever we write after it. So here it is:
cout << “Hello World!”;
So the compiler knows that we want the computer to produce this particular output “Hello World”. So, in the end, what does are code look like? Something like this:
#include <iostream>
using namespace std;
int main () {
#instruction here
cout << “Hello World”;
return 0;
}
If you give this to a compiler, it will understand exactly what you are talking about, and create a program that can be execute on whatever OS your compiler is for. Sweet, right?
Review: Tengen Toppa Guren Lagaan
Jun0
About an hour ago, I just finished watching the Anime Tengen Toppa Guren Lagaan, a relatively new anime that came out a couple of years ago. It interested me because I read a manga spinoff earlier, and it’s also made by one the studios I like, Gainax.
Introduction to the Story
The beginning of the show centers around three characters. Shimon and Kamina are residents of an underground city, who dream of going to the surface. Shimon is a digger, digging holes to increase the size of the city, while Kamina is a sort of motivator, talking about the dreams that he has to arrive at the surface. One day, Shimon discovers a giant robotic head, and as he is about to show Kamina, a large robot crashes down into the city, threatening to destroy. A girl known as Yoko also comes down, attempting to bring down the robot. Shimon find out the giant head is also a robot, and with the help of Kamina and Yoko, defeats the large robot, and inadvertently ends up on the surface.
Now onto the actual review!
Story
Generally, the story of Tengen Toppa is probably one of the better ones for something that is originally an anime (not adapted from a manga). The story is fairly structured, and the characters actually show some depth, as well as overcome both physical and emotional hardships. Of course, I wouldn’t expect any less from the production company behind Evangelion.
Now, the story has an incredibly fast pacing. If the goal was to see how much story one could cram into 27 episodes, that’s a good example. Each arc is completely different from the other, and almost every episode feels necessary to the story. However, fast pacing has it’s consequences. Although no episode is particularly boring, the story introduces a lot of characters without giving a lot of explanation regarding backstory. Sometimes I feel like this character was invented just for one or two parts of the story, and then completely disregarded afterward. In fact, I felt this way about one of the main characters for at least the first 8 episodes.
If I give Tengen Toppa one thing, it’s the fact that it’s pretty much unpredictable. The twists and turns that occur are enough to cause a headache, and without a lot of time to explain, there was a lot of concepts and themes that could have been explored further.
Story: 4/5: Exhilarating, but needed to slow down to spend more time on characters and understanding what the heck is going on.
Production
Gainax is an amazing production company. Every single thing I’ve seen from them is amazing visually. Tengen Toppa is not exception. The art style really portrays the feelings and intensity of the characters, and all scenes are very well animated. You really get the sense that this is quality work. The style also takes on more of classic-robot-anime touch at some points, with thick brush lines and everything. I think this was to increase the intensity, and it sure did the trick.
Regarding the actual art style, it takes more of a 90’s Anime approach, compared to the ridiculously shiny and vibrant colors of other recent Animes.
Save for a strangely animated 4th episode (even the co-founder of Gainax had some negative things to say), the production was very well done.
Production: 5/5 fits it perfectly, and increases the intensity of the Anime.
Sound
Voice actors are top notch. I don’t really know too much about voice actors, but I do know that the voices fit perfectly, especially since this show needs some talented ones.
The music was also very good. I guess the show has it’s own original soundtrack, and the music perfectly complements every scene its in.
Sound: 5/5 very good!
Overall
Tengen Toppa Guren Lagaan kept me glued to my computer for two days straight, so I’d say it did a very good job. Besides a slightly erratic and hard to understand story, it did a very good job. Gainax sure has a knack for Mecha Anime’s.
Overall: 4.5/5
All about Signals
Jun1
I liked my signals class for EE so much, I wrote a song for it:
It’s hard to read, so I’ll just type it here:
A whole new woooooorld
A new fantastic point of viewww
Frequencies are fast or slow, and their transforms show
When you use a fil-ter
Seriously, I loved this signals class.
A good idea
May0
A good idea is like a bird: It might come back a second time, but don’t count on it. Take a picture just in case.
red + icul + ous = 23!!!
May1
Today I saw the movie “23″, starring Jim Carrey. It came out in about 2007. The movie is based around the myth that everything is somehow correlated with the number 23. You can read more about it here.
Now, 23 isn’t the most common number, so it would be incredibly coincidental to show up everywhere. But what about permutations of 23? We’re talking maybe the digits 2 and 3, or maybe 3 and 2. Maybe the numbers add up to 23. Or maybe it’s 5 (2+3) or 1 (3-2)? Let’s a little bit deeper into that.
There are four single-digit numbers related to 23: 1, 2, 3, and 5. Now let’s include multiples: 2*3 = 6. So 1,2,3,5, and 6. That’s 50% of all single digit numbers. So, if it’s a single digit number, there’s already a 1/2 chance that it has to do with 23.
But that’s not really a big deal. In fact, any two-digit number has at least a 40% chance or being related. Let’s take a look at another unrelated number, like 76. Let’s see the single digits correlated to it:
7, 6, 7+6 = 13. 7*6 = 42, so:
1,2,3,6, and 7 have to do with 76. What? There’s also a 1/2 chance this is possible to? How is this possible? Well, it’s just looking at a problem creativly.
How about number that add up to 23? There’s 22 different combinations of those. As for numbers that subtract to 23? Since there’s infinite numbers, there’s also an infinite number of combinations that subtract to 23:
24 – 1 = 23
25 – 2 = 23
26 – 3 = 23
and so, continuing to infinity.
Of course, adding and subtracting to another number is just as likely. Infinite combinations for adding and subtracting.
Now how about adding more than 2? I’m not going to talk about subtraction from now on, since there’s infinite combinations.
For 3 digits, such as:
21 + 1 + 1 = 23
15 + 3 + 5 = 23
There are 297 total permutations. To find unique permutations (we’re going to stop including different orders), we have:
297/3! = 50 permutations.
But wait! That’s not all! Some 23 theorists also use permutations of 32. So let’s test that:
558/3! = 93
so we already have over 140 permutations to choose from. A lot of random numbers we can use to make it seem like the number actually holds some significance.
These number just get bigger. For example, now let’s look at four digits combinations:
23 made out of 4 digits = 2596/4! = 108
32 made out of 4 digits = 6541/4! = 272
So that’s another 350+ permutations to play with. Now, with 1/2 of the single digit numbers, over 140 permutations of 2 numbers, and over 300 permutations of 3 numbers, It’s very easy to make it seem like the number 23 holds some significance.
How about that fact that 2/3 = 0.666? Well, a 2/3rds ratio between numbers is quite common. I guess it’s interesting that it’s the lowest common denominator, but that’s only because they’re both prime.
So to summarrize:
The chance of 23 showing up somewhere is just about as likely as any other number showing up.
Since we use numbers to represent a lot of things, the chances of seeing a permutation of 23 is pretty high.
In the end, numbers are just abstract concepts which we give value to. To say that 23 is a magic number is like saying that 0 degrees Celsius is a magic number because it’s the freezing point of water.
Who knows? Maybe the real magic number is 32, and we’ve had it all around the whole time. My bet’s on some clever operations though.
Note: This also assumes we use a base 10 counting system. Another counting system and none of these “coincidences” would occur. Of course, we would have a completely different set of them.
Yusuketsutsumi.com
Aug0
Yusuketsutsumi.com is finally finished! If you are an employer, feel free to explore my website and learn more about your potential employee. If you’re just here to visit, take a look around! All of my major projects are listed on this web page.