We caught up with Chris Wright at the Red Hat Summit to discuss how the oVirt sessions were going, and why people are so excited to see open source bring a virtualization tool to the market. oVirt works across platforms and architectures to meet the challenge of managing virtualization in the datacenter. For more information, check out http://ovirt.org.

If you are new to Python Web Development, then I’d recommend Django, as it is ideal for building CMS-type applications, social networking websites, and blogs. On the other hand, If you want a hacker’s framework, you might want to give Pylons a look.

Please note: By hacker, I am referring to the kind of hacker Eric Raymond refers to when he writes, “Becoming a hacker will take intelligence, practice, dedication, and hard work. Therefore, you have to learn to distrust attitude and respect competence of every kind. Hackers won’t let posers waste their time, but they worship competence — especially competence at hacking, but competence at anything is valued.”

Ok, so what problem does a hacker’s framework solve that a framework like Django doesn’t? According to some of the Pylons developers, their framework is geared to solve 80/20 problems. Most people—80% of people–want to build blogs, and CMS-type applications. And for that 80%, Django works just great. Of course, the other 20% is where Pylons comes in to play as a “hacker’s framework.”

Philosophically, Pylons is quite different. Pylons abstracts third-party libraries, such as WebOb, Mako, SQLAlchemy, Routes, and Beaker, to make a “hacker’s brew.” These libraries are loosely coupled–not in a internet marketing sense, but in a computer science sense. This means that it is quite easy to swap out the ORM, or templates, or URL routing, and create some alternate development stack. Note, that another hacker’s framework, Werkzeug, also follows a similar philosophy (See the references for more details).

What does a hacker’s framework buy you? Well, it allows you to change your web development paradigm. You no longer need to think in terms of what you can do with the choices defined by a framework. It allows the experienced developer to transcend this potential trap, and think about the actual problem at hand. For example, it may be more productive to start by using SQLAlchemy (the object-relational mapper) by itself.

Once the data model is working as expected, then it could turn into a command line tool, then potentially a WXPython application instead of a web application. Hacker’s frameworks let the developer decide what is best for them at any given situation. Additionally, by focusing on loosely coupling the “best of breed” components, it allows the user of a “hacker” framework, to use literally, the best component for the job. This extra power can come in handy with more complex problems.

Setup

In this article we dive into building an AJAX blog using Pylons. We cheat by using the bookmark tagging site, Del.icio.us as an admin interface that we don’t have to write. When a user creates content on Delicious, the Google AJAX feed API allows that content to be displayed locally on the web page. This is one of the most efficient type of blog that someone can create, as it reuses existing code, APIs, and services.

Building a Pylons AJAX blog

To get started you can download the whole example and run it, or you can follow the steps below. Note that in version control, each step is a separate Pylons project.

[ Step 1] http://code.google.com/p/pyatl-pylons/source/browse/#svn/trunk/1

1: Download http://www.pylonshq.com/download/0.9.7/go-pylons.py

ngift@noah][H:10471][J:0]# python gopylons.py --no-site-packages pylonsblog
New python executable in pylonsblog/bin/python
Installing setuptools..........................done.
Searching for Pylons
[snip]

Note: You will need to meet all requirements of the package.

2:

cd pylonsblog

3: Active environ

source bin/activate

4: Make project

mkdir -p src
paster create --template=pylons ajaxblog

5: Get Pylons running

cd ajaxblog

paster serve development.ini

6: Make a controller

paster controller blog

cd ajaxblog/controller to verify

go to page:

http://localhost:5000/blog

See Hello World, change it.

"Hello Red Hat Magazine"

[Step 2] http://code.google.com/p/pyatl-pylons/source/browse/#svn/trunk/step2

7: Change front page

Add your own content to public/index.html

8: Add a couple of templates, and hook up to blog controller

Create base.html
Create blog.html

Add this line to blog.html:

Hello from blog.html template: Red Hat Magazine

9: Change controller to render template

Edit controller/blog.py to this:

class BlogController(BaseController):

    def index(self):
        # Return a rendered template
        #   return render('/some/template.mako')
        # or, Return a response
        return render('/blog.html')

[Step 3] http://code.google.com/p/pyatl-pylons/source/browse/#svn/trunk/step3

10: Get Buzzword compliant: Adding AJAX, RSS, Mashup and Google

A. Sign up for AJAX RSS Developer Key:

http://code.google.com/apis/ajaxfeeds/

B. Add javascript Code to base.html
C. Call feed div in blog.html

11: See RSS Feed appear

If you go to localhost:5000/blog you will see my last RSS feeds

[Step 4] http://code.google.com/p/pyatl-pylons/source/browse/#svn/trunk/step4

Bonus Points: Try to add persistent comments using the SQLAlchemy ORM on your own!

Summary

In this article we explored some of the ideas behind Pylons, a hacker’s framework, and how it differs from a philosophy framework, like Django or Ruby on Rails. Note by philosophy framework, I am referring to how a developer must abide by the opinions of the developer of the framework, such as in the case of Django templates where a developer is handcuffed against running code in the template. For example, their idea of perfection might be different then yours. Some people refer to this as being an “opinionated” framework. Each one has its purpose, and place. If you just want to make a Content Management website MS website for your American Literature class project, then maybe a hacker’s framework isn’t suited for you or the project, as it is overkill. On the other hand, if you want maximum flexibility, power, (and, of course, “street cred”) you might give a hacker’s framework a try.

Finally, we got into making an actual Pylons AJAX blog that used Delicious to suck in feeds. This was accomplished by reusing code via the Google AJAX Feed API. Ok, enough talk, get to hacking….

Extra Credit: If you are interested diving into a more complex Pylons project template on your own take a look at this source code url. Jonathan Ellis, a Python hacker known for his work with SQLAlchemy, has donated a do-it-yourself tutorial on using FormAlchemy to create a simple blog in Pylons. I have included a link to his original article on the topic in the reference section.

References

Pylons Book: http://pylonsbook.com/alpha1/toc
Google AJAX Feed API: http://code.google.com/apis/ajaxfeeds/
SQLAlchemy: http://www.sqlalchemy.org/
Using SQLAlchemy: http://www.ibm.com/developerworks/aix/library/au-sqlalchemy/
How To Become a Hacker: http://www.catb.org/~esr/faqs/hacker-howto.html
Google App Engine: http://code.google.com/appengine/
WebOb: http://pythonpaste.org/webob/
Source Code For Example: http://pyatl-pylons.googlecode.com/svn/trunk/
Werkzeug (An alternate hacker’s framework): http://werkzeug.pocoo.org
Loose Coupling Computer Science Definition: http://en.wikipedia.org/wiki/Loose_coupling#Definition
Pylons FormAlchemy How To: http://spyced.blogspot.com/2008/10/formalchemy-10.html
Extra Credit Project: http://code.google.com/p/pyatl-pylons/source/browse/#svn/trunk/bonus_project_form_validation_jonathan_ellis

About the author

Noah Gift is the co-author of “Python For Unix and Linux” by O’Reilly, and “Google App Engine in Action” by Manning. He is an author, speaker, consultant, and community leader, writing for publications such as IBM Developerworks, Red Hat Magazine, O’Reilly, Manning and MacTech. He has a Master’s degree in CIS from Cal State Los Angeles, B.S. in Nutritional Science from Cal Poly San Luis Obispo, is an Apple and LPI certified sysadmin, and has worked at companies such as, Caltech, Disney Feature Animation, Sony Imageworks, Turner Studios, and–most recently–WetaDigital.

1. What does Jopr do?
Jopr is an open source project that provides an integrated management platform that simplifies the development, testing, deployment, and monitoring of your JBoss technologies. From a single console you can inventory and monitor resources from the operating system to deployed applications. It also lets users control and audit application configurations to standardize deployments. It’s a robust solution to manage, monitor, and tune your applications for improved visibility, performance, and availability.

2. What about Embedded Jopr?
Embedded Jopr provides many of the same features as Jopr, but only for a single instance or (in the near future) a cluster of JBoss technologies. It’s essentially an administration console to manage JBoss products–users don’t have to rely so much on command line and XML configuration to set up their JBoss environment and applications.

It doesn’t offer the extensive monitoring and historical auditing capabilities of Jopr, but it is perfect for an individual developer or administrator to use. In contrast, Jopr is what you use to manage the entire enterprise or multiple instances and clusters from one location.

3. How does Jopr fit in with JON and RHQ?
RHQ is the platform on which Jopr is written. RHQ provides a very extensible plug-in technology that allows for many other technologies to be managed. Jopr includes all of the existing RHQ plugins, plus JBoss-specific ones. In turn, Jopr is the true upstream to commercial JBoss Operations Network (JON).

So you could think of it this way: RHQ is upstream to Jopr, which is upstream to JBoss Operations Network.

4. How did the project get started?
The project has really been in the works for a while, starting when it was becoming clear that JBoss needed a tool to help enable solutions for “non-developers” as the JBoss footprint continued to grow.

Typically, the groups responsible for operations in an environment are not the developers, so they need a different set of tools. Most operations staff are concerned with uptime and making sure the environment is compliant and ready to use for the customers they support. Jopr is the open source solution to provide that for JBoss technologies.

5. Tell us about the name.
Well, the team actually went through what seemed like hundreds of names, but almost every one we were close to choosing had some sort of issue where it was taken, trademarked, or just not “sticky” enough. So legend has it that a 1983 Matthew Broderick and Ally Sheedy flick called War Games was the eventual inspiration.

The real star of the movie was an artificial intelligence computer the military used called W.O.P.R. (pronounced whopper). From this, Jopr was born (it’s not a acronym as in the movie–that would have opened an entire other set of issues for getting a trademark). So it met the criteria of not being taken, it could be trademarked. And it was definitely “sticky,” as there is really no project, especially not in the Java space, that is even close.

6. So how is Embedded Jopr different from the consoles that have shipped with JBoss Application Server in the past?
Previous consoles for the application server were designed with a “developer” in mind, so they required some JBoss and Java expertise to use. With Embedded Jopr (and really, Jopr, too), it’s all about enabling JBoss for operations by making administrative and management tasks easier. We hope that with the open source community helping us, we can continue to push that goal forward.

7. Can anyone contribute? How would they get involved?
Absolutely! Just go to http://www.jboss.org/jopr or http://www.jboss.org/embjopr and join us!

Related links
http://www.jboss.org/jopr
http://www.jboss.org/embjopr
http://www.jboss.org/feeds/
(scroll down to JBoss ON section for many of the development team blogs)
http://www.rhq-project.org

In the second installment of the Spotlight On series, we feature Red Hat engineer Richard Hughes on the fantastic new abstraction layer called PackageKit. PackageKit allows users to manage packages in a secure way using a cross-distro, cross-architecture API. This maintains a common set of GUI features, enabling the user to have a better session experience overall. For more information, visit www.packagekit.org.

To summarize, the process is:
1)Get the new code accepted upstream.
2)Get it included in Fedora.
3)Get it included in Red Hat Enterprise Linux.

Although this article focuses on the Linux kernel, the steps apply to all Red Hat Enterprise Linux components and packages.

The key element in the process is that Red Hat tracks upstream. This means that Red Hat works closely with the open source community. Any new features must first be accepted upstream before they’re added to Red Hat Enterprise Linux.

There are numerous benefits to this approach. The biggest is that it keeps the OS and its users closely aligned with Linux as it evolves. There are no dead-end branches, incompatible features, or Red Hat-specific changes that must be maintained. New features added to Linux and key packages are easily integrated. It also means that all new development can and must be accepted by the community before integration.

There are also a number of challenges to the open source model. Some of these are misconceptions, while others have at least a kernel of truth.

Open source: Multiple paths to new capabilities
With proprietary software, only the owner of the software can add new features and capabilities. This makes the question of new functions quite straightforward. There is one source for new features, and they either agree to or reject a request for a new feature. If they don’t agree to add the requested function, there’s no recourse.

With open source development, there are many ways to add a new capability:

• The original author of the package can add it.
• The Linux distributor (such as Red Hat) can add it.
• You can customize your installation by adding it yourself.
• You can contract with or persuade someone to add it for you.
• Perhaps most importantly, anyone can add it.

With open source, it isn’t a question of who can add or enhance a feature or capability, it is a question of how widely that feature will be adopted. This changes the dynamics of adding new features from one of focusing solely on writing the code that implements the feature to one of addressing creation, integration, acceptance, and adoption.

Of course you can make any changes you want to your own copy of the code. But if you want broad use and support of your new features or bugfixes, you need to go through an acceptance process where other groups are persuaded to distribute and support the new code.

There is no single point of control in open source—there is no one who can order a new feature to be accepted. Red Hat can’t demand that others accept new developments by Red Hat. By virtue of being a recognized leader, we have considerable influence, but we must work within the community structure. This community includes not just programmers, but interface designers, testers, documentation writers, project managers, support people, and marketers.

So what’s Red Hat’s involvement?
Red Hat is both a developer/contributor and an integrator. We consciously chose to do targeted development and to build on the work of thousands of other participants in the open source community. That is, we want to be a part of this community, rather than going on our own. In some cases we look to the people with a vested interest in a new feature—for example, a driver for a new piece of hardware—to develop the needed software and push it upstream (i.e. get it accepted).

In part 2 of this article, we’ll talk about open source development and licenses.

Red Hat engineer Dan Williams demonstrates the shared networking capabilities of Fedora 10.

We here at Red Hat are pleased to bring you a brand new set of videos aimed at showing off the latest and greatest enhancements in our technologies–featuring the very people who helped create them in the first place. The “SPOTLIGHT ON” series highlights the ways in which collaboration drives innovation by looking at projects that have been improved by community input. In our first installment, we track down Red Hat’s own Karsten Wade and Stephen Smoogen from the University of New Mexico to talk about Extra Packages for Enterprise Linux (EPEL), the Fedora-sourced repository of add-on packages for Red Hat Enterprise Linux. They discuss how EPEL is a tool for user-driven innovation that comes from and benefits enterprise customers with more stable code and lower business costs.

Background

The dd command is one of those ancient UNIX tools that is extremely powerful, yet at the same time, the syntax can make it feel slightly archaic. A lot of seasoned sysadmins and developers still remember the first time they saw the dd command used by a bearded wizard. He might have used it to test the disk I/O, capture a disk image, or restore it.

In some ways, dd can seem like Old Spice–only the guys over 60 use it. But the younger generation should know that dd still has some tricks up its sleeve. In this article, we’re going to put a new twist on this old favorite and show how grandpappy really does know best sometimes. The new twist is to mix dd with Python and the Google Chart API to make a UNIX 2.0 mashup tool. (”UNIX 2.0″ is a play on words for what happens when you change the original behavior of a tool like dd to make it do something a bit different.)

Setup

For this article, we assume you’re running Fedora Core 8. We’re actually just renting some time from Amazon in all of these examples. To do that we allocated a 1 GB Elastic Block Storage volume from Amazon and attached it as the device /dev/sdd to an Amazon Machine Instance (AMI) running Fedora Core 8. Learn more about using Amazon Cloud Computing with Red Hat.

Using dd for disk benchmarking with Google Charts API and Python

We benchmarked the throughput of the disk by running the dd command with various block sizes from 128 KB to 1 MB. (Note: If you want to run the script on your own machine, make sure that the volume you use doesn’t contain any valuable data, because the data will be erased by the dd command. Remember, data loss makes grandpappy mad!)

For the benchmark, we wrote a Python script that uses the commands module to run and capture the output of the dd command. The script also uses the csv module to generate a comma-separated values file so that we can graph the results later. For this example, we chose to graph the results using the Google Chart API.

#!/usr/bin/env python
import commands
import re
import csv

Next we define the main function, which takes a device name and a block size as parameters, and returns the throughput measured with dd and the unit of measure (e.g. MB/s). We use the regular expression module (re) to isolate the throughput value and unit of measure from the output of the dd command.

Editor’s note: In the code below, unit = "" has been added since the article was posted.

def get_disk_throughput(device, blocksize):

    blocksize = str(blocksize) + 'k'

    cmd = "dd if=/dev/zero of=%s bs=%s" % (device, blocksize)

    output = commands.getoutput(cmd)

    throughput = 0

    unit = ""

    for line in output.split('n'):

        s = re.search(' copied,.*, (S+) (S+)$', line)

        if s:

            throughput = s.group(1)

            unit = s.group(2)

            break

    return (throughput, unit)

Here is the portion of the script that is executed when it’s run from the command line. We open a csv file and associate it with a csv writer. We then use the writerow method of the writer to append the header and each data row. We iterate over the list of block sizes and call the get_disk_throughput function for each block size.

We also compose the Google Chart URL by filling in the exact data values, represented by the throughput numbers that we obtain from the get_disk_throughput function. Then we print the URL to stdout. If you check the URL, you’ll see the chart generated with our data.

For details on the Google Chart API and what each parameter to the URL represents, see the Developer’s Guide.

Editor’s note: This is an updated version of the code that originally appeared with this article. It has command-line argument processing, and it composes the Google Chart URL in a better, more self-explanatory fashion. See the end of the article for the original.

f = open('disk_throughput.csv', 'w')
        writer = csv.writer(f)
        writer.writerow( ('Block size (KB)', 'Throughput') )
        blocksizes = [128, 256, 512, 1024]
        gchart_url = "http://chart.apis.google.com/chart?"
        gchart_type = "cht=bvs"
        gchart_title = "&chtt=Disk%20throughput"
        gchart_size = "&chs=400x250"
        gchart_axis_labels = "&chxt=x,y"
        gchart_data = "&chd=t:"
        gchart_labels = "&chl="
        max_t = 0.0
        for blocksize in blocksizes:
            (t, u) = get_disk_throughput(device, blocksize)
            if float(t) > max_t:
                max_t = float(t)
            writer.writerow( (blocksize, t) )
            print 'Block Size: %sk Throughput: %s %s' % (blocksize, t, u)
            gchart_data += t + ","
            gchart_labels += str(blocksize) + "k" + "|"
        gchart_data = gchart_data.rstrip(',')
        gchart_labels = gchart_labels.rstrip('|')
        gchart_axis_range = "&chxr=1,0," + str(max_t+10.0)
        gchart_scaling = "&chds=0," + str(max_t+10.0)
        gchart_url += gchart_type + gchart_title + gchart_size + gchart_data + gchart_labels
        gchart_url += gchart_axis_labels + gchart_axis_range + gchart_scaling
        print "Google Chart URL (just paste in a browser):", gchart_url
    finally:
        f.close()

Here is the output of the script in one of our runs:

Block Size: 128 Throughput: 62.8 MB/s

Block Size: 256 Throughput: 61.8 MB/s

Block Size: 512 Throughput: 57.1 MB/s

Block Size: 1024 Throughput: 56.5 MB/s

Now here is the actual image that gets created:

Full script

#!/usr/bin/env python

import sys
import commands
import re
import csv
from optparse import OptionParser

def get_disk_throughput(device, blocksize):
    blocksize = str(blocksize) + 'k'
    cmd = "dd if=/dev/zero of=%s bs=%s" % (device, blocksize)
    output = commands.getoutput(cmd)
    throughput = 0
    unit = ""
    for line in output.split('n'):
        s = re.search(' copied,.*, (S+) (S+)$', line)
        if s:
            throughput = s.group(1)
            unit = s.group(2)
            break
    return (throughput, unit)

if __name__ == "__main__":

    usage = "usage: %prog options"
    parser = OptionParser(usage=usage)
    parser.add_option("-d", "--device", dest="device",
            help="Disk device to operate on (NOTE: any data on that device will be lost)")
    (options, args) = parser.parse_args()
    device = options.device
    if not device:
        parser.print_help()
        sys.exit(1)

    try:
        f = open('disk_throughput.csv', 'w')
        writer = csv.writer(f)
        writer.writerow( ('Block size (KB)', 'Throughput') )
        blocksizes = [128, 256, 512, 1024]
        gchart_url = "http://chart.apis.google.com/chart?"
        gchart_type = "cht=bvs"
        gchart_title = "&chtt=Disk%20throughput"
        gchart_size = "&chs=400x250"
        gchart_axis_labels = "&chxt=x,y"
        gchart_data = "&chd=t:"
        gchart_labels = "&chl="
        max_t = 0.0
        for blocksize in blocksizes:
            (t, u) = get_disk_throughput(device, blocksize)
            if float(t) > max_t:
                max_t = float(t)
            writer.writerow( (blocksize, t) )
            print 'Block Size: %sk Throughput: %s %s' % (blocksize, t, u)
            gchart_data += t + ","
            gchart_labels += str(blocksize) + "k" + "|"
        gchart_data = gchart_data.rstrip(',')
        gchart_labels = gchart_labels.rstrip('|')
        gchart_axis_range = "&chxr=1,0," + str(max_t+10.0)
        gchart_scaling = "&chds=0," + str(max_t+10.0)
        gchart_url += gchart_type + gchart_title + gchart_size + gchart_data + gchart_labels
        gchart_url += gchart_axis_labels + gchart_axis_range + gchart_scaling
        print "Google Chart URL (just paste in a browser):", gchart_url
    finally:
        f.close()

Summary

In this article we shattered the myth that you must be 60, have a massive grey beard, and have worked at Bell Labs to use the dd command. Even for a newer generation, dd can be used in some inventive ways. We combined Python, the Google Chart API, and Red Hat on Amazon’s cloud computing infrastructure to create a novel way to measure and chart disk I/O and performance. Go celebrate by buying yourself a bottle of Old Spice.

References

Python: http://www.python.org/
dd example scripts: http://tldp.org/LDP/abs/html/extmisc.html
Google Chart API: http://code.google.com/apis/chart/

Original code

if __name__ == "__main__":

    try:

        f = open('disk_throughput.csv', 'w')

        writer = csv.writer(f)

        writer.writerow( ('Block size (KB)', 'Throughput') )

        device = '/dev/sdd'

        blocksizes = [128, 256, 512, 1024]

        google_chart_url = "http://chart.apis.google.com/chart?cht=bvs&chd=t:"

        google_chart_data = ""

        google_chart_labels = ""

        max_t = 0.0

        for blocksize in blocksizes:

            (t, u) = get_disk_throughput(device, blocksize)

            if float(t) > max_t:

                max_t = float(t)

            writer.writerow( (blocksize, t) )

            print 'Block Size: %s Throughput: %s %s' % (blocksize, t, u)

            google_chart_data += t + ","

            google_chart_labels += str(blocksize) + "k" + "|"

        google_chart_data = google_chart_data.rstrip(',')

        google_chart_labels = google_chart_labels.rstrip('|')

        google_chart_url += google_chart_data +"&chl=" + google_chart_labels

        google_chart_url += "&chtt=Disk%20throughput" +"&chs=400x250&chxt=x,y"

        google_chart_url += "&chxr=1,0,%s&chds=0,%s" % (str(max_t+10.0), str(max_t+10.0))

        print google_chart_url

    finally:

        f.close()

Authors

Noah Gift is the co-author of Python For Unix and Linux by O’Reilly, and Google App Engine in Action by Manning. He is an author, speaker, consultant, and community leader, writing for publications such as IBM Developerworks, Red Hat Magazine, O’Reilly, Manning, and MacTech. He has a master’s degree in CIS from Cal State Los Angeles, a B.S. in nutritional science from Cal Poly San Luis Obispo, and is an Apple and LPI certified sys admin. He’s worked at companies that include Caltech, Disney Feature Animation, Sony Imageworks, Turner Studios, and most recently, WetaDigital.

Grig Gheorghiu is the director of technology for RIS Technology, a web hosting company based in Los Angeles. Grig has 15 years industry experience, during which time he has worked as a programmer, research lab manager, system/network/security architect, IT consultant, and lead test engineer.

Grig is an active member of the Python and agile testing communities. He maintains a blog dedicated to agile testing, Python programming, and automated testing tools and techniques. Grig is the founder of the Southern California Python Interest Group, aka “the SoCal Piggies”. He lives in Los Angeles with his wife and two children.

If using a proxy server, Satellite will initiate connections to port 5222 on each proxy server connected. This is used for communications relating to the “OSA” service (also known as “Push to Client“). If using the OSA service, access to this port should not be restricted.

A Satellite service will also connect to individual client systems on port 4545 if the monitoring service be enabled on these specific systems. This port needs to be unrestricted if the RHN Monitoring service is being used.

For Proxy:

The RHN proxy server will connect to ports 80 and 443 on the “upstream” system, either RHN Hosted or an internal Satellite server.

If the Monitoring Scout is enabled on a proxy server, then the proxy will initiate connections to port 4545 on Monitoring-enabled client systems.

For Client Systems:

Client systems will initiate connections to ports 80 and 443 of their upstream RHN server (Satellite, Proxy or RHN Hosted).

If OSA is being used, then the client systems will also connect to the Jabber service running on the Satellite or Proxy server, on port 5269.

Red Hat’s customer service and support teams receive technical support questions from users all over the world. Red Hat technicians add the questions and answers to Red Hat Knowledgebase on a daily basis. Access to Red Hat Knowledgebase is free. Red Hat Magazine offers a preview into the Red Hat Knowledgebase by highlighting some of the most recent entries. The information provided in this article is for your information only. The origin of this information may be internal or external to Red Hat. While Red Hat attempts to verify the validity of this information before it is posted, Red Hat makes no express or implied claims to its validity.

Everybody wants to be heard. Some of us have a rhythm to go along with it.

I was introduced to ccmixter a couple months ago and have been hooked ever since. It is a utopia of sound for music makers and mixers alike.

From acapellas and samples to remixes, ccmixter wants you to download, sample, cut-up, and share music of all types. Some artists post entire albums for the community to remix.

Best of all, it’s all licensed under Creative Commons so there’s no worries.

Check out my page of remixes.

If you create a remix and want to get in touch with Napoleon–or just have a question–feel free to leave a comment (or contact information) on this post.