beck917\’s blog

基本上就是把页面全部抓下来…这样可以备份评论…还有模板,图片..

推荐用firefox离线浏览比较好…

解压后点击运行main.exe
比如beck917.blogbus.com,你只需要在弹出的dos对话框中输入beck917,然后点击回车…用了多线程,所以速度还算可以…

点击此处下载

http://fallingbullets.com/blog/2006/aug/06/wordpress-clone-27-seconds-part-1-40/

原文在这，在Django的官方wiki上有这篇教程，我看了之后忍不住想翻译出来，无奈得等到下班回家，郁闷~~

首先我先稍微介绍下，WordPress 是一个十分流行的开源的php写blog程序，以前也曾经翻译过关于wordpress钩子机制的文章，这篇文章使用python的流行框架Django 来写一个类似WordPress的blog程序，当然不可能像Wp那么强大啦，27秒也有些shock，单纯的copy作者写的代码还差不多

The WordPress Clone articles will guide you through the creation of a blog system in Django that has tags, feeds, a portfolio section, and the ability to sync up with your Flickr and Ma.gnolia accounts. Essentially, I’m just going to rip the source code From this site, throw some witty commentary on it, and pass it off as a comprehensive tutorial series that not only clears acne but removes old and set-in stains From your favorite clothes. I’m clever like that, I guess.

这篇克隆Wordpress的文章将引导你用Django编写一个有tags，feeds，a portfolio section[不才，这个是虾米我不知道....]，并能够同步你的 Flickr 和 Ma.gnolia帐 户的blog系统.本来，我只是想剖析这个站点的源代码，在上面加上一些注释，并当作一个完整的指南系列完成它，它不仅可以清除粉刺还能消除你喜爱的衣服 上的污渍（译者注：我靠，耍我的吧，谁知道这句怎么翻译啊…那要是有这神奇功效，大家一定要读完=。=）.我猜,我很聪明.(=.=)

The Basics

基础

First off, I’m assuming that you know the basics of Django. You’ve got it installed, running smoothly under whatever esoteric database you’ve decided to torment yourself with, and you’ve run through the official Django tutorial. You can syncdb like you ain’t ever syncdb’d before. You’re also well-versed in a few web framework jokes and can incite flame wars in #rubyonrails by ending all your comments with end. If you’ve got that down, you’re half-way there.

现在，我就这样牛13的认为你已经掌握了Django的基础.你已经安装并且在深奥的数据库下平稳的运行了,你已经决定决定用官方的教程折磨你自 己,你已经精通少数framework的笑话,并能够嘲笑ROR中所有的东西都是通过end来结束,如果你做到这些,那么你已经上路了[译者注:作者真是 相当的幽默啊~~可是偶翻译不出来~~]

Enough with the small talk. Put Tom Tom Club on the stereo and let’s get this party rolling.

好了,废话说到这,将Tom Tom Club调到立体声,我们开始这场摇滚盛宴~~

The Project

项目

Run django-admin.py startproject mysite to create the project folder. You can, of course, use whatever project name you want, but I'm going to use mysite throughout these tutorials for the sake of simplicity. 运行django-admin.py startproject mysite

创建一个项目文件夹.你能,当然,用你想用的项目名称,但是我简单起见,将用mysite(这个项目名)贯穿整个指南.

Set all your settings in settings.py to your liking. Make sure ROOT_URLCONF is correct and add 'mysite.blog', to your INSTALLED_APPS setting. "Wait a minute!" you're saying, "What's that last line?" That's our first app - the blog!

投你所好,在setting.py里设置你的 settings.确保ROOT_URLCONF是正确的,同时将"mysite.blog"加入你的INSTALL_APPS设置里."稍等!!"你吼 道,"最后一行是什么",哦,那是我们的app(译者注:在Django里有很多的小app,这有点像wordpress里的钩子机制)---- blog.

The Blog

博客

To create the blog app, run django-admin.py startapp blog From your project folder. Django will create the basic files for the blog app.

去创建一个blog app,先从你的项目文件夹里运行django-admin.py startapp blog,Django将会为你的blog app自动创建基本的文件

The Model

模型

Open up the models.py file in your blog app’s folder, and create the following models:

打开你blog app文件夹下的models.py,并创建下面的models:

From django.db import modelsclass Tag(models.Model):
name = models.CharField(maxlength=50, core=True)
slug = models.SlugField(prepopulate_from=("name",))class Admin:
pass
def __str__(self):
return self.namedef get_absolute_url(self):
return "/blog/tags/%s/" % (self.slug)class Entry(models.Model):
title = models.CharField(maxlength=200)
slug = models.SlugField(
unique_for_date='pub_date',
prepopulate_from=('title',),
help_text='Automatically built From the title.'
)
summary = models.TextField(help_text="One paragraph. Don't add tag.")
body = models.TextField()
pub_date = models.DateTimeField()
tags = models.ManyToManyField(Tag, filter_interface=models.HORIZONTAL)class Meta:
ordering = ('-pub_date',)
get_latest_by = 'pub_date'

class Admin:
list_display = (’pub_date’, ‘title’)
search_fields = ['title', 'summary', 'body']

def __str__(self):
return self.title

def get_absolute_url(self):
return “/blog/%s/%s/” % (self.pub_date.strftime(”%Y/%b/%d”).lower(), self.slug)

There’s two main classes here: Tag and Entry. Let’s look at Entry:

这里有两个main class :Tag和Entry.让我们看看Entry:

• title, summary, and body: The meat and bones of our blog posts. When we get to the templates, we’re going to use summary on the home page and in blog entry listings to give viewers a quick summary of the blog entry instead of presenting them with the first paragraph or X words of our blog’s body.
• title,summary和body:是发表blog的肉和骨头.当我们接触到模板,我们将会用在首页上用summary(摘要),在blog文章列表中呈现出一个敏捷的日志摘要代替呈现出首段或者我们blog的主题的X(大写字母??)
• slug: The entry’s identifying string. Think of it as a textual id, except it doesn’t have to be unique among all Entry objects—just those sharing the same publish date.
• slug:文章条目的识别字符串. 想想它像一个文本 id,除了它不用必须在所有的条目中唯一—-只是那些共享的相同的发布日期(难以理解原文意思)
• pub_date: This contains the date and time that you “published” this blog entry. This serves two purposes, actually. First, it’s the date this entry was published (duh) and defines the blog entry’s generic view URL. Second, it acts as a “publish on” date. Django doesn’t list entries that have a date in the future in your date-based generic views. You can pre-schedule posts to make it appear as though you really did post your thesis on the applicability of string theory to the production of two-ply toilet paper when you were actually out getting butchered at the pub.
• pub_date:这个字段包含你发布在这个blog中的日期和时间.这样做实际上有两个目的.第一,这是这条日志发布的时间和定义blog日志 页面的通用view URL.第二,这扮演了”publish on”日期.Django 不能列出一个用未来日期表示的通用views.你可以提前发帖,这样看起来好像你真的发了一篇文章…..胡言乱语ing….
• tags: This ManyToManyField relationship to the Tag model allows us to select any number of tags From a global pool of tags, much like every other blogging program out there.
• tags:这个对tag model多对多的关系允许我们从tags聚合中选择随意数量的tags,很像所有其他的blog程序一样

We also have some methods inside our Entry model that do important things:

在Entry model中我们也有一些函数做重要的事情:

__str__(self): This returns a human-readable string that represents this Entry. This will be used in the admin interface later on.

__str__(self):这返回一个用户友好的字符串.这个不久将会被用在admin界面中

get_absolute_url(self): This returns the absolute URL to this blog entry. At the moment, Django doesn’t have an automated way of creating URLs automatically. Doing so is difficult because Django lets you specify your own URL patterns. Recently, however, there have been some talk about doing something about this. Until then, you’ll have to write your own methods to return the URL.

get_absolute_url(self):这返回一个blog条目的绝对URL.在这个时刻,Django没用用一种自动的方式创建 URLs.因为Django会让你用定制你自己的URL正则,所以这是一件蛮棘手的事.最近,不论如何,我们得说说怎样做这件事情.到那时,你不得不写自 己的方法以返回URL

The URLs

The next step in setting up our blog is telling Django what URLs to look for so it can shoot the right data to the right template.

下一步就是告诉Django寻找什么样的URl能够指向正确的模板

Most people tend to throw all their URLs into the root URL file until they have a ten megabyte file that would make even the most seasoned Perl coder cry at night. I like to have one entry in the root urls.py file for each app which catches all URLs for that app and turns them over to the app’s own urls.py file. However, to keep things simple for this tutorial, we’ll use a monolithic urls.py file. If you want to create a modularized URL system, feel free.

大多数人倾向所有他们的URLs都扔到根URL文件直到有10m那么大,就算是老练的perl程序员都会在深夜哭啼[注: 作者真tmd太幽默了].我倾向于在根urls.py有一个统一的入口,然后如果是有其他的app,则交给那个app自己的urls.py处理.但是,为 了保持这个指南的简单性,我们只用一个urls.py.如果你想创建一个模块化的URl系统,那很简单.

Paste the following in to the urls.py file in your project’s root folder:

将下面的代码copy到你项目的根目录下的urls.py文件:

From django.conf.urls.defaults import *
From mysite.blog.models import Entryblog_dict = {
‘queryset’: Entry.objects.all(),
‘date_field’: ‘pub_date’,
}

urlpatterns = patterns(”,
(r’^blog/(?P<year>\d{4})/(?P<month>[a-z]{3})/(?P<day>\w{1,2})/(?P<slug>[-\w]+)/$’, ‘django.views.generic.date_based.object_detail’, dict(blog_dict, slug_field=’slug’)),
(r’^blog/?$’, ‘django.views.generic.date_based.archive_index’, blog_dict),
)

The first two lines are the imports we need to bring in the relevant data structures and methods. I have no idea exactly what the first import includes. Maybe it includes magic pixie dust and a big ol’pocket-full of dreams. I do know, however, that the second line is the import that includes the Entry model From our blog’s models.py file so that we can access the blog entries From our database.

前两行是import我们需要的相关的数据结构(类)和方法.严格来说我不知道第一个应该 import哪一个include.也许它引入了魔法小仙子和我们萝莉的白日梦[注:我真欠扁,这里应该怎么翻译].第二行在我们blog的 models.py中引入了Entry model.所以我们能够在数据库中获取条目..

The blog_dict dictionary we’re building here is the foundation for blog’s generic views. We pass this dictionary of information to the generic views and the generic view code works its mojo on the data we’ve stored in the dictionary. The different generic views take in different sets of data, so check up on the generic view documentation if you want to do anything funky. The queryset is the collection of data that we want the date-based views to choose from. You could, conceivably, use the well-documented database API to only pass in entries that contain more than 200 spelling and grammatical errors, but we’re not trying to clone LiveJournal, now, are we?

建立blog_dict这个字典是blog的通用 views的基础.我们向通用view传递这个字典的信息,这个通用链接的代码驱动在我们已经在字典中存储数据的mojo(注:不晓得是什么东西).不同 的通用views接受不同的数据,如果你想找点刺激的话可以去查一下通用view的文档(官网上).queryset是我们供我们挑选基于日期的view 的一个数据集合.你可以,令人信服的,用对文档友好的数据库API传递有着200个以上的拼写和语法错误的条目,但是我们不是在尝试克隆 LiveJournal,不是吗?

The workhorse of urls.py files is the urlpatterns. This contains a list of RegEx patterns that Django matches incoming requests with to send the user the correct view and template. I’ve only included the pattern for the blog archive page and the blog entry detail page and not the other date-based archive pages. URL patterns are documented plenty well in other places, so I’ll leave the bits and pieces up to you. Just make sure you know what’s going on in those lines before you try anything fancy yourself. It’s all fun and games until someone loses an eye.

urls.py文件中做粗活的当属urlpatterns了.这包含了 Django匹配发送非用户正确的view和模板的正则表达式列表.我只是包含了用于blog文章存档页面和blog文章页面的pattern,但是没有 其他基于日期的存档页面的pattern.URL patterns 在其他地方有丰富的文档,所以我们将这些零碎的地方交给你解决.你只需要保持清醒,不要自我迷恋,在我们继续之前,一切都非常有趣知道某些人迷失自我~

Activating the Automagic Administration Interface

自动的后台用户界面
Django’s auto-admin interface is one of its biggest selling points. Let’s activate it so you too can take part of the magic. Or something. Anyways, let’s get it on:

Django的全自动的用户界面是巨大的卖点之一 .让我们激活他,你会感受到他的神奇的,或者其他什么,不关怎样,我们开始吧~

1. Open settings.py and add 'django.contrib.admin', to your INSTALLED_APPS setting. This adds the admin app to your project.
2. 打开settings.py并在你的INSTALLED_APPS中添加”django.contrib.amin”,这会将admin app 添加到你的项目中
3. We need to access the admin app through a URL (of course), so open your urls.py file and add the following to urlpatterns: (r'^admin/', include('django.contrib.admin.urls')), This line imports all of the admin interface’s URL patterns.
4. 我们需要一个指向admin界面的URL(废话…),所以打开的你的urls.py添加下面的urlpatterns((r'^admin/', include('django.contrib.admin.urls')),这行将include
   admin 界面的URL patterns.
5. Imagine Jeff Goldblum saying “There is no step three!” and giggling in that odd choppy way he did in that Apple commercial. Man, that was weird.
6. 幻想家 jeffGoldblum说过:”没有第三步”,然后傻笑他在苹果贸易中临时变卦.伙计,这真tmd诡异.

Go ahead and run syncdb. If this is the first time you’ve run syncdb on this project, it will ask you to create an administrator user. It creates the user or else it gets the hose again.

继续,然后run syncdb,如果这是你在这个项目中第一次运行syncdb,Django会问你是否创建管理用户帐号.它创建用户,否则it gets the hose again.

Intermission

间断

Now that you’ve created the essentials of the blog, why not have some fun in the administration interface and add some fake blog entries. We’ll need them when we start messing around with the templates.

现在实际上你已经创建了一个blog,我们为什么不尝试一下管理用户界面,然后发布一些伪造的blog条目呢,在我们开始在模板上浪费时间之前我们需要这样.

Templates

模板

Templates with generic views are a cinch. All you have to do is create files with the right names, throw down some tag soup, and everything will work (really!).

有通用链接的模板是容易做到的.你不得不用正确的名字创建这些文件,throw down some tag soup ,所有的都会运行(当然).

First, create the templates/ directory wherever you told Django it would be (hint: the TEMPLATE_DIRS variable in settings.py). Then create a folder with the same name as your app inside templates/ (so, for our example, you’ll have mysite/templates/blog/). Inside that folder, create the following empty files: entry_archive.html and entry_detail.html.

首先,创建模板和模板所在的文件夹,无论如何你得告诉Django怎么做(提示:TEMPLATE_DIRS在settings.py中).然后创 建一个与你在templates/(所以,例如,你有将会有 mysite/templates/blog/)中的app相同名字的文件夹.创建下面的空文件entry_archive.html and entry_detail.html.

Base Template

基本模板

Thanks to Django’s excellent template system, we can use inheritance to save ourselves a lot of repeated code. Let’s create our base HTML template at the root of our templates/ directory. This HTML file is going to be the basis for every page in our site. Let’s be creative and call it base.html. Wild!

干些Django提供这么棒的模板系统,我们可以继承我们重复的代码. 让我们在templates/的根目录下创建基本的HTML模板.这些HTML文件将会作为这个站点每个页面的基础.让我们创建它然后命名为base.html.哦耶~~

Base Template

Thanks to Django’s excellent template system, we can use inheritance to save ourselves a lot of repeated code. Let’s create our base HTML template at the root of our templates/ directory. This HTML file is going to be the basis for every page in our site. Let’s be creative and call it base.html. Wild!

Throw in the following HTML:

放出下面的代码:

Throw in the following HTML:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
    <title>My Site - {% block title %}{% endblock %}</title>

    <meta http-equiv="content-type" content="text/html; charset=utf-8" />
</head>
<body>
    <div id="header">
        <h1><a href="/">My Interweb Tubes Blog</a></h1>
        <h2>It's not a truck!</h2>

        <ul id="nav">
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
            <li><a href="#">Photos</a></li>
            <li><a href="/links/">Links</a></li>
            <li><a href="/portfolio/">Work</a></li>
            <li><a href="/colophon/">Colophon</a></li>
        </ul>
    </div>
    <div id="content">
        {% block content %}

        {% endblock %}
    </div>
</body>
</html>

This HTML is going to be present across our entire site, only with
different content. The menu includes links to the sections we’ll be
creating in later parts of this tutorial series. That is, unless I get
run over by a truck. Again.

这个HTML将会成为整个站点的父模板,只是内容不一样而已.这个菜单上的链接连到我们下面的章节中将要创建的文件. 换句话说,除非我再次用卡车碾过去.(=.=什么嘛…)

Blog Archive Template

blog存档模板

To keep this tutorial short (well, shorter than it could be if I introduced every single generic view), the only generic view we’re going to implement for our blog is django.views.generic.date_based.archive_index, which is simply a date-ordered list of all our blog objects.

为了保持教程的简明(好吧…比我一个一个的介绍每个通用的view要少好吧…) ,唯一的我们要继承自django.views.generic.date_based.archeive_index的通用view,是一个简单的按日期排序的列表.

Paste the following code in to templates/blog/entry_archive.html:

粘贴下面的代码到templates/blog/entry_archive.html

{% extends "base.html" %}

{% block title %}Latest Blog Entries{% endblock %}

{% block content %}

<h1>Latest Blog Entries</h1>

<ol id="object-list">

{% for object in latest %}

<li>

<h2><a href="{{ object.get_absolute_url }}">{{ object.title|escape }}</a></h2>

<p class="post-date">{{ object.pub_date|date:"F j, Y" }}</p>

<p class="summary">{{ object.summary }}</p>

</li>

{% endfor %}

</ol>

{% endblock %}

Let’s see what each of the template tags do:

让我们看看每个模板标签都干些什么:

• {% extends "base.html" %}: This lets us build on top of base.html and fill in the empty blocks we created—specifically title and content.
• {% extends "base.html" %}:这个让我们在最上面创建base.html,然后用我们需要的title和content填充它.
• {% block title %}Latest Blog Entries{% endblock %}: This fills in our empty title block in the base template.
• {% block title %}Latest Blog Entries{% endblock %}:这个填充我们基础模板中的title区域
• {% block content %}: Same as {% block title %}:we’re going to fill in the empty block in base.html with our blog entries.
• {% block content %}: Same as {% block title %}:我们继续用我们的blog条目填base.html中充空的区域
• {% for object in latest %}: One of the things generic views does for us is to fill in important context variables that we need. In this template, we need a date-ordered list of the blog entries in the database. django.views.generic.date_based.archive_index puts that information in the latest context variable. This tag iterates over the latest list of blog entries and puts each one in object for us to access.
• {% for object in latest %}:通用view代替我们填充context变量是一件非常重要的事.我们需要blog条目在数据库中按时间排序.django.views.generic.date_based.archive_index将信息放入最后的context变量中,这个标记循环列出最新的条目…
• {{ object.get_absolute_url }}: This calls the get_absolute_url(self) method we created in the Entry model earlier, which gives us the absolute URL to the blog post.
• {{ object.get_absolute_url }}:这个会调用get_absolute_url(self)函数,我们刚才在Entry模块创建的,它会给我们发布的blog
• {{ object.title|escape }}: This tag inserts the entry’s title. the | character pipes the title through the escape filter, which escapes all character entities that need to be escaped. This allows us to create blog titles like “<br /> Considered Harmful” without having to do the entity codes ourselves in the blog entry’s admin interface.
• {{ object.title|escape }}:这个标记插入到条目的名称中,字符”|”是让title通过 escape过滤,将会替换所有我们需要替换的特殊字符.他允许我们像这样”<br /> Considered Harmful”创建blog名称,而不需要我们自己在blog条目的发布页面手动做
• {{ object.pub_date|date:"F j, Y" }}: Much like the title tag, this tag pipes some data through a filter. In this case, it’s the date filter, which allows us to format the date any way we choose. Read [Django's documentation on the now tag](http://www.djangoproject.com/documentation/templates/#now) for more information on the ways you can format the output.
• {{ object.pub_date|date:"F j, Y" }}:想title标记一样,这个标记让一些日期通过一个过滤器.既然这样,这个过滤器,允许我们以任何我们喜欢的方式格式化日期.阅读 [Django's documentation on the now tag](http://www.djangoproject.com/documentation/templates/#now)以获却更多的信息过于格式化输出.
• {{ object.summary }}: This tag simply spits out our entry’s summary.
• {{ object.summary }}:这个标记输出我们的标记.

And we’re done! Run python manage.py runserver and navigate to http://localhost:8000/blog to see your archive view in action. If you get Django’s 404 page, it means that you haven’t added any blog entries yet.

好了,我们做好了.运行 python manage.py runserver ,并且浏览 http://localhost:8000/blog,就能够看到你的日志存档了.如果你看到了一个Django的404错误页面,那么这说明你还没有发布任何的blog文章.

Blog Detail Template

blog详细模板

Finally, our links to blog entries are useless unless we give Django a template to display the entry details. Open up entry_detail.html and paste in the following:

最后,我们链接到blog文章页面我们不得不创建一个详细页面的模板.打开entry_detail.html并粘贴下面的代码

{% extends "base.html" %}

{% block title %}Blog - {{ object.title|escape }}{% endblock %}

{% block content %}

<h1>{{ object.title|escape }}</h1>

<dl>

<dt>Posted On:</dt>

<dd>{{ object.pub_date|date:"F j, Y" }}</dd>

<dt>Tags:</dt>

<dd>

{% for tag in object.tags.all %}

<a href="{{ tag.get_absolute_url }}">{{ tag.name }}</a>{% if not forloop.last %}, {% endif %}

{% endfor %}

</dd>

</dl>

{{ object.body }}

{% endblock %}

Much of this should be familiar by now. Note, however, that the generic view puts the relevant blog entry in to the object context variable. Run runserver and try out the new detail view.

Post Mortem

In the next tutorial, we’re going to learn how to add CSS to our site using the media directories and how to implement custom views to allow us to display a list of entries by tags (i.e. http://localhost:8000/blogs/tags/my-tag-slug).

在下一个指南中,我们继续学校怎样用 the media directories 添加css到你的站点 ,并且学习怎样继承通用view去允许我们通过tags显示条目列表.

You can download the tutorial project as it stands so far here: mysite_tutorial_1.zip.

当然你可以在这里下载到现在为止的所有代码:mysite_tutorial_1.zip.

 doubanclaim848cf0450828e20c

究竟什么是心理成熟？心理成熟的确切标准是什么？每个心理专家都有自己的解释。其中美国心理学家赫威斯特列举了10项发展任务，可视为青年人心理成熟的标准。不妨对照一下——你的心理成熟吗？
1.能在日常生活中与同龄人建立和谐的人际关系，包括同性朋友和异性朋友在内。

2.在行为上能够扮演适当的性别角色。

3 .接纳自己的身体和容貌。不过分炫耀自己的优点，也不过分掩饰自己的缺点，发挥最大潜能。

4.情绪表达渐趋成熟独立。凡事不再依赖父母或其他成人的支持与保护。

5.有经济独立的信心。

6.能够选择适合自己能力和兴趣的职业，而且肯努力奋发，为取得该种职业而准备。

7.认真考虑选择婚姻对象，并开始准备成家过独立的家庭生活。
8.在知识、观念等各方面，都能达到作为一个公民所需要的标准。
9.乐于参与社会活动，也能在社会活动中对自己的行为负责任。
10.在个人的行为导向上，能建立起自己的价值道德标准。

nnd，再更新一篇，平时木有时间，下周争取记录些学习c语言的细节，要不好好的一个技术blog又被我糟蹋了~~

话说回家后，有一件艰巨的任务。。。买耳麦。。我那可怜的耳麦已经over，换个新的，旧的不去新的不来，本来本周想在JN买，无奈回家，不过好处是家里的电脑城我是相当的熟悉啦。。原来工作的地方楼下几层就是~~嘿嘿~~那里货好我还是有所了解滴~~

直奔微软，罗技键鼠代理的商家了。。第一眼看见的就是传说中的Audio 90，哇~~上学的时候就向往的啊，一度进入偶瞎拼list的,问了问价格，150….残念，偶此次预算只有15好吧，你去个零我才买的起。。。=。=，反正偶有不是cs达人，电脑上也没必要搞hifi，lowfi就好。。。=，=，自我安慰ing

传说中的Plantronics Audio 90

算了，放弃，不过dz这地方能见到A90偶已满足。。刚要走，就看见一个仿的超级像森海的耳麦。。。nnd，稀饭啊。。问了价格，随便听了下。。（其实只要出声就好），拿下。。25大洋。超出预算10米，忍了

上图

回来后才看清，原来跟我上一个一样，也是somic的。。。残念，不过做工还不错哈~~

刚回来，手机没电，想也没法通知胖子，什么叫缘分啊，打开电脑，还没插上耳麦，就看见胖子了，问之，刚来10分钟，之后狂聊。。。。=。=

另外最近打算在43things找个想学习中文的国际友人（=。=）交流英语。。=。=不知道可行度多高

附上本人缓解郁闷TOP5(no order)

1.狂灌冰镇可乐，本人不喝酒，此为替代方案

2.拿足球解气，一个人去球场，对着墙踢球~free kick也是好方案，玩WE也是替代方案

3.睡懒觉，狂睡那种。。醒着脑子胡思乱想，不如睡觉，说不定还能做美梦==

4.瞎拼，买新鲜东西瞎鼓捣，嘿嘿，然后还可以小小炫耀下。。=。=

5.拽个无辜的好友，狂砍，胡砍，乱砍，完全不顾对方是否在听。。。据说射手座最怕一个人的时候，人多了什么都忘了。。。=。=

现在已经是“法定”的睡觉时间了，我也有些许困倦，但是还是决定写完此篇blog再睡~~

十年，我不是说香港回归十周年，那固然意义重大，但对于我们这些平常人是感觉不到的，去香港那不知道是多少年以后的事了，回归了有匝地，不像出国似的签证也得办手续，麻烦~~像茶馆中所说的，莫谈国事~~进入正题

中国vs伊朗

十年前，那个下午，大连金州，我，在家，看电视，第一次跟随着中国队体验冲击世界杯

十年后，傍晚，马来西亚，我，在外地的家，半场电脑网络，半场在快餐店，亚洲杯

十年前，领先两球，我，兴奋，满屋子跑，最后被反超，2：4，失落，第一次体验到当中国队球迷的悲哀和痛苦

十年后，领先两球，我，已经习惯，仅仅是兴奋的叫嚷，毕竟仅仅是亚洲杯，最后被扳平，2：2，心情平淡，已经习惯，况且这场比赛平局和胜利没有太大差别，唯一是97年看球以来90分钟比赛内中国队从来没有战胜过伊朗，这已经不是恐韩之类的，这是实力的差距，平静对待。

说实话，我已经基本上一年没有看中国队的比赛了，完全完全的失望，垃圾足协政策完全在国奥身上，国家队哪像是国家队，从97年看球以来，无论别人怎么骂中国足球，我总是能从中寻找希望，那些已经被淡忘掉的年轻球员，那些灵光一现的年轻球员~~

整个中国都是这样，何况中国足球呢，年轻球员有激情，有技术，有梦想，有追求，可是那些老球员怎么教年轻球员的，他们的经验是腐败的，是肮脏的，他们教的是让这些球员学会腐败学会肮脏，忘记梦想，淹没激情，对，不只是中国足球，整个中国都是这样。

实在不想扯到自己的工作中，但也无奈，我像那些年轻球员一样，看到了那些我的前辈那种傲慢的态度，时代在发展，年轻人比你们强是在正常不过的事情了，对于后来人，我都能做到自叹不如，你们呢？计算机这个行业本来就是日新月异的，长江后浪推前浪，更应该向后来人学习请教，或者退一步，是交流，而不是一味的灌输自己愚昧的观点~~

十年也许仅仅是一个轮回，我还是祝福中国足球一路走好~~