A Few Hundred

You could accomplish the following by using a graphical package installer like Synaptic or the Ubuntu Software Center, but in the spirit of do-it-once-and-forget-it-forever, try the following command which can be pasted into your command prompt (Terminal).

sudo apt-get install fonts-cantarell lmodern ttf-aenigma ttf-georgewilliams ttf-bitstream-vera ttf-sjfonts ttf-tuffy tv-fonts

Even More

If, somehow, the fonts installed by all of the above packages are not enough for you, try one more.

sudo apt-get install ubuntustudio-font-meta

This is a meta package linking together many other packages. It will install quite a bit to your system, including some bit for programs and languages you might not need.

One way or another, between all these, you’re not likely to run out of new fonts any time soon.

The post How to Install Hundreds of Fonts at Once in Ubuntu [Quick Tips] appeared first on Make Tech Easier.

1. Gnome 3 with Gnome Shell

Let’s get the most obvious choice out of the way first. Historically, Ubuntu has always run the Gnome desktop environment. Gnome was one of the first DEs for Linux, and is still going strong. When they recently released version 3, it was a complete overhaul of both the desktop interface and much of the software behind it. Currently, Ubuntu uses Gnome 3′s backend software with the Unity desktop, but if you want the full Gnome 3 experience you need Gnome Shell.

As regular readers may know, we’ve covered Gnome Shell in detail several times before.

Gnome shell can be installed through the Ubuntu Software Center, or from the command line with

sudo apt-get install gnome-shell

2. KDE

The other big kid on the block is KDE. It and Gnome have been battling for the Linux desktop for years, each with their own group of avid supporters. As one of the heavyweight contenders, KDE packs a full suite of mature and capable software, a beautiful desktop, and decades of Linux desktop design experience.

All of KDE’s power and flexibility does not come cheap. A full KDE installation is a pretty hefty thing, and for all its fine points, KDE might not be a great option for low end or mobile computers.

KDE can be installed through the Ubuntu Software Center or from the command line with

sudo apt-get install kde-standard

or if you want, download Kubuntu, which comes with KDE as the default DE.

3. XFCE

For a long time, XFCE was jokingly known as “Gnome Lite”. It uses similar backend software (such as GTK) and has an overall look and feel similar to the Gnome 2.x series. It’s generally regarded as lighter and faster than Gnome, however most of those comparisons were made prior to Gnome 3. Now the two desktops take such vastly different approaches, and such comparisons would have less meaning.

Still, its resemblance to Gnome 2 is much of the reason why many people (including Linus Torvalds himself) have migrated to XFCE due to dissatisfaction with Gnome 3.

XFCE can be installed through the Ubuntu Software Center or from the command line with

sudo apt-get install xfce4

or download Xubuntu which comes with XFCE.

4. LXDE

A lightweight option that’s been growing in popularity lately is LXDE. It’s a desktop environment built around the OpenBox window manager. It includes several small apps and utilities like the PCManFM file manager and a custom panel and terminal.

LXDE is a fairly nice setup, particularly on lower-end machines, but it’s been this author’s experience that LXDE and its related apps always seem to have the feel of being almost done. If you’re the type of user who likes everything to be smoothly polished, feature-complete, and rock-solid – LXDE might not be great for you. If, however, you need something light, fast, and simple – I highly recommend you try it out. It may not be your dream desktop, but it’s almost there.

LXDE can be installed through the Ubuntu Software Center or from the command line with

sudo apt-get install lxde

5. Enlightenment (E17)

Once considered a thing of myth and legend, E17 is now a part of Ubuntu 11.10′s online repositories. Many years of development have gone in to this release, and it’s got loads of features. This is a desktop that aims to do it all – high performance, high productivity, extreme flexibility, and loads of eye candy. Chances are it does not much resemble any desktop environment you’ve used before, so if you decide to take the plunge, be prepared for a little bit of a learning curve.

Once you’ve learned to do things the “enlightened” way, it may be tough to switch back. E17 can be installed through the Ubuntu Software Center or from the command line with

sudo apt-get install e17

Conclusion

Each of these has its own pros and cons. Some people love Gnome 3, some think it’s garbage. Some people use KDE every day, others won’t go near it. The beauty of Linux is that whatever you like, you can have it – for free. If it doesn’t exist, make it. That’s what open source is all about: choice. Hopefully this guide has helped you make yours.

The post 5 Alternatives to Unity in Ubuntu Oneiric appeared first on Make Tech Easier.

A Bit About “The Cloud”

As with many tech buzzwords, you might get a different definition of this term from each person you ask. Some might describe it as a way of scaling your computing resources to fit your needs.

Let’s say ABC Books, a local book store wants to run a site where their customers can buy books online. The “traditional” approach would be for someone to dust off a server, install an OS, run a webserver application and load their site on it.

When virtualization was becoming popular, people started using another method called the Virtual Private Server or VPS. With this method, you can have multiple operating systems running on the same machine, each with their own setup and applications.

This allows each user to have full control over their system, but without the expense of dedicated hardware. ABC Books, our example complany, would likely save money by switching to VPS, as they don’t need the server’s full power and can share the cost with other users. The “cloud” method takes virtualization even further. Since you’re already virtualizing the software, what happens if you virtualize the hardware too? The essence of cloud computing is taking a huge collection of computing resources and intelligently assigning them as needed. Take this diagram for example.

You can see that most of the portions are different sizes. ABC Books might only need a portion of one server, but Bob’s House of Free iPads might generate more traffic and need multiple servers. One of the greatest benefits of cloud computing is that you can scale your resources up and down as needed.

Let’s say a huge celebrity talks about their love of ABC Books, and suddenly the site is getting hundreds of times the amount of traffic it normally would. Their dedicated server is probably not equipped to handle that. Likewise, a VPS (though more flexible) will still need a hardware transfer or upgrade to keep up. A cloud based server, however, could just be “turned up” to handle the excess traffic. When the buzz has died down, you just reduce your resources back to normal.

Signing up for EC2

Note: The free account is indeed free, but during the signup, you will be asked for credit card information. See Amazon’s terms for details.

Log in or create your Amazon EC2 account. Unfortunately, new user registrations can sometimes remain pending for several hours.

Once your Amazon Web Services account is set up, you can access your management console by clicking the Sign In to AWS Management Console link in the top-right corner of aws.amazon.com or clicking here.

Creating an Instance

Once your account is activated and you’re able to access the AWS Console, you’ll probably want to start by creating server instance to run some software.

The first thing you’ll be asked to do is decide on a base platform. The Amazon Linux is a good bet if you’re looking to demo the service.

The next page lets you set some details regarding your instance. You’ll probably want to leave these settings as they are, seeing as how the free tier only supports the Micro instance type, and Availability Zone should make no difference at this stage.

The next page, Advanced Instance Options, should be left at defaults unless you have a specific reason to do otherwise.

The last step of your Instance Options is the one where you choose tags. This step is optional, and nothing will be broken if you specify no tags, but it’s recommended to at least apply a value to the Name key to make this instance easy to identify.

The next step is to create a key pair. Instead of passwords, EC2 uses cryptographic keys to identify users. If that sounds confusing don’t worry, it’s really not that complicated. The first step is to name and generate a key pair, then download that to your computer. I’d recommend saving it to ~/.ssh/.

Once you’ve got the keys saved, you’ll need to make sure it’s private. You cannot skip this step, as SSH will refuse to use a publicly viewable key. It’s quick and easy to set this, just open your Linux or OSX terminal and type:

chmod 600 ~/.ssh/MyEC2Key.pem

and to actually use it to connect, go with

#You will of course have to wait until your instance is actually running
ssh -i ~/.ssh/MyEC2Key.pem root@your-ec2-dns-address.com

Finally, you’ve just got to open a hole in the firewall for your app. The dropdown list contains several common network options such as SSH, DNS, and of course HTTP. If you want to enter a custom port, here’s your chance.

Once you review and launch your instance, you’re set! You can now use SSH as indicated above to connect to your public DNS (highlighted in the screenshot below).

Conclusion

From here on out, it’s your “server” to deal with as you wish. Applications can be installed and removed however you see fit. The service is can be tailored to exactly the application you have in mind – anything from a web server to VPN gateway to a place to host your files. Good luck and have fun on the cloud!

The post Getting Started with Amazon EC2 appeared first on Make Tech Easier.

CPU Load

We’ll start with the most obvious cause of PC slowness – processor overload. As you’re reading this website, it’s got various bits of JavaScript running. Each time you load the page, the JavaScript is read as text, interpreted by your browser, passed to your operating system which loads system libraries and passes the data to your kernel – which works through the hardware drivers to actually run the program through your CPU. We get the convenience of being able to have a single script run on nearly every computer, but all that interpretation and data passing can really hammer down your system performance.

The most basic way to check your CPU load is with the command-line utility top. It contains a lot of information, but it really shines when trying to make comparisons between the CPU and RAM usage of various applications.

In that screenshot, you can see that top sorts the entries with the highest usage on top, so that you can see right away what’s using the most CPU or RAM, and the result is shown in percentages.

It’s worth noting that on a machine with multiple cores, it’s quite possible that the percentages top shows you will total up to more than 100% (ie, one core is 70% of max and another is 60%, top might show 130% usage).

RAM Usage

Next to CPU, your RAM (or lack thereof) is the mostly likely culprit of performance problems. Most MakeTechEasier readers are probably familiar with how RAM works, but here’s a quick primer for those who don’t.

Let’s say you’re at a library, and the new Larry Porter and the Prince of Bologna book is out. Normally, fantasy books are kept in the basement, but these books are hugely popular, so the library staff keeps a stack of them right at the front desk. This means that the library patrons can grab their book quickly and easily without going to the basement, it’s a win-win for everyone. That all sounds great, but you can’t do that with EVERY book in the library. Since the staff cannot keep a single convenient shelf for every book they have, most of them get kept in sections such as the basement.

That’s similar to how hard drives and RAM work. The hard drive, in this analogy, would be the basement shelves. It’s well suited to long-term, organized storage. The RAM is the smaller area by the front desk, and space specifically suited to hold the most needed items so that they can be retrieved quickly.

If you’ve got too much in your RAM (too many programs and services running) then the computer’s ability to retrieve the needed information can be drastically reduced. Suddenly it’s got to sort through a giant stack of stuff instead of just grabbing what it needs.

While it’s true that the free command will give you basic memory info, this is another case where top can come in very handy. Instead of simply showing “X mb free”, top will give you the detailed numbers, percentages, and swap usage information.

Take note of the swap usage information. On an average desktop, the percentage of used swap space should generally be very low. If it’s not, you may have to just go out and buy more RAM (or seriously reduce the amount of running programs.)

Overworked Hard Drive

Is your hard drive light constantly chugging along, yet you have no idea what it’s doing? Mysterious input/output can sure be a problem, so there is a top-like tool called iotop specifically meant to help diagnose this kind of problem.

It is not, however, built in to many distributions so you’ll likely have to install it separately. It should be available in your distro’s repositories, but if not you can download it here.

A normal, idle system should be mostly zeros across the board, sometimes with a few small bursts while data is being written, as in the screenshot below.

If however, you run a disk-intensive utility like find, you’ll see its name and throughput listed clearly in iotop.

Now, you can easily find out what program is using your I/O (in this case I ran “find / -name chicken”), who ran it, the speed the data is being read, and more.

GUI Tools

The author of this post chose command line tools to gather this information for two main reasons. First, CLI tools generally require fewer resources than GUI tools, and second, tools like top can be found in just about any Linux system, where as GUI tools can be hit-or-miss.

Many people do not like the command line, and there are several GUI tools to perform system monitoring, but this author recommends Gnome System Monitor. It’s already available on just about any Gnome-based distribution, and includes a lot of useful information including realtime graphs for CPU, memory, and network.

Conclusion

While there are many things that can potentially cause system slowness those three things (CPU, RAM, and disk I/O) are behind the vast majority of performance problems. Using the tools described here won’t solve your performance problem, but they’ll make the cause of the problem a whole lot easier to find.

The post Linux Running Too Slow? Here’s How to Find the Cause appeared first on Make Tech Easier.

Using These Prompts

Some of the following prompts are one-liners, and can be pasted directly into your terminal for (temporary) use. To make them permanent, you’ll have to paste the code into your .bashrc or .bash_profile.

The larger, more complex prompts such as Twtty should be saved to their own script file (such as myprompt.sh), and you place a line like

source myprompt.sh

in your .basrc file to “import” them.

Twtty Prompt

This is a two-line prompt that holds quite a bit of information including username, hostname, working directory, time, and command history number. Because of the technical and visual complexity, it’s best to place this prompt script in its own file, then source it from your .bashrc or .bash_profile as described above.

function prompt_command {
 
TERMWIDTH=${COLUMNS}
 
#   Calculate the width of the prompt:
 
hostnam=$(echo -n $HOSTNAME | sed -e "s/[\.].*//")
#   "whoami" and "pwd" include a trailing newline
usernam=$(whoami)
cur_tty=$(tty | sed -e "s/.*tty\(.*\)/\1/")
newPWD="${PWD}"
#   Add all the accessories below ...
let promptsize=$(echo -n "--(${usernam}@${hostnam}:${cur_tty})---(${PWD})--" \
                 | wc -c | tr -d " ")
let fillsize=${TERMWIDTH}-${promptsize}
fill=""
while [ "$fillsize" -gt "0" ] 
do 
    fill="${fill}-"
	let fillsize=${fillsize}-1
done
 
if [ "$fillsize" -lt "0" ]
then
   let cut=3-${fillsize}
	newPWD="...$(echo -n $PWD | sed -e "s/\(^.\{$cut\}\)\(.*\)/\2/")"
fi
}
 
PROMPT_COMMAND=prompt_command
 
function twtty {
 
local GRAY="\[\033[1;30m\]"
local LIGHT_GRAY="\[\033[0;37m\]"
local WHITE="\[\033[1;37m\]"
local NO_COLOUR="\[\033[0m\]"
 
local LIGHT_BLUE="\[\033[1;34m\]"
local YELLOW="\[\033[1;33m\]"
 
case $TERM in
    xterm*)
        TITLEBAR='\[\033]0;\u@\h:\w\007\]'
        ;;
    *)
        TITLEBAR=""
        ;;
esac
 
PS1="$TITLEBAR\
$YELLOW-$LIGHT_BLUE-(\
$YELLOW\$usernam$LIGHT_BLUE@$YELLOW\$hostnam$LIGHT_BLUE:$WHITE\$cur_tty\
${LIGHT_BLUE})-${YELLOW}-\${fill}${LIGHT_BLUE}-(\
$YELLOW\${newPWD}\
$LIGHT_BLUE)-$YELLOW-\
\n\
$YELLOW-$LIGHT_BLUE-(\
$YELLOW\$(date +%H%M)$LIGHT_BLUE:$YELLOW\$(date \"+%a,%d %b %y\")\
$LIGHT_BLUE:$WHITE\$$LIGHT_BLUE)-\
$YELLOW-\
$NO_COLOUR " 
 
PS2="$LIGHT_BLUE-$YELLOW-$YELLOW-$NO_COLOUR "
}

One important thing to note about this prompt is that the horizontal bar scales to fit the width of your terminal, and that the working directory line will truncate itself when it gets too large.

If you have any problems with the above code snippet, the plain text version can be downloaded here.

High-Performance Minimalist Prompt

All the complexities of a fancy prompt like Twtty do take up extra CPU cycles, and while it’s certainly not going to grind your system to a halt, it can add up. If you want something that packs a lot of info without slowing you down, I suggest this:

PS1="[\d | \T -> \w ...\$?]\n#"

One interesting thing to note here is the use of the variable $? at the end. This signifies the exit status of the last command entered. 0 means all is well, any other number usually indicates an error.

Rob’s Prompt

This is one of the more popular prompts floating around the Internet. The code is small and simple, yet it gives many of the features found in the larger, more complex examples.

PS1="\[\033[0;33m\][\!]\`if [[ \$? = "0" ]]; then echo "\\[\\033[32m\\]"; else echo "\\[\\033[31m\\]"; fi\`[\u.\h: \`if [[ `pwd|wc -c|tr -d " "` > 18 ]]; then echo "\\W"; else echo "\\w"; fi\`]\$\[\033[0m\] "; echo -ne "\033]0;`hostname -s`:`pwd`\007"

MegaFancyPrompt

The name is entirely deserved – this prompt is quite large and extremely fancy. It’s got color, titlebar control, user-awareness, proxy detection, screen detection, job count, and more. In short, just about every feature found in the other prompts we’ve mentioned can be found here, and quite a few others. If you want it ALL in your prompt, this is it.

Note: Not all features are visible at all times, so while it may not look like much in the screenshot, you can check out the full (documented, commented) script file here for details on how to get the visible parts you want.

COLOR_WHITE='\033[1;37m'
COLOR_LIGHTGRAY='033[0;37m'
COLOR_GRAY='\033[1;30m'
COLOR_BLACK='\033[0;30m'
COLOR_RED='\033[0;31m'
COLOR_LIGHTRED='\033[1;31m'
COLOR_GREEN='\033[0;32m'
COLOR_LIGHTGREEN='\033[1;32m'
COLOR_BROWN='\033[0;33m'
COLOR_YELLOW='\033[1;33m'
COLOR_BLUE='\033[0;34m'
COLOR_LIGHTBLUE='\033[1;34m'
COLOR_PURPLE='\033[0;35m'
COLOR_PINK='\033[1;35m'
COLOR_CYAN='\033[0;36m'
COLOR_LIGHTCYAN='\033[1;36m'
COLOR_DEFAULT='\033[0m'
 
# Function to set prompt_command to.
function promptcmd () {
    history -a 
    local SSH_FLAG=0
    local TTY=$(tty | awk -F/dev/ '{print $2}')
    if [[ ${TTY} ]]; then 
        local SESS_SRC=$(who | grep "$TTY "  | awk '{print $6 }')
    fi
 
    # Titlebar
    case ${TERM} in 
        xterm*  )  
            local TITLEBAR='\[\033]0;\u@\h: { \w }  \007\]'
            ;;
        *       )  
            local TITLEBAR=''                               
            ;;
    esac
    PS1="${TITLEBAR}"
 
    # Test for day change.
    if [ -z $DAY ] ; then
        export DAY=$(date +%A)
    else
        local today=$(date +%A)
        if [ "${DAY}" != "${today}" ]; then
            PS1="${PS1}\n\[${COLOR_GREEN}\]Day changed to $(date '+%A, %d %B %Y').\n"
            export DAY=$today
       fi
    fi
 
    # User
    if [ ${UID} -eq 0 ] ; then
        if [ "${USER}" == "${LOGNAME}" ]; then
            if [[ ${SUDO_USER} ]]; then
                PS1="${PS1}\[${COLOR_RED}\]\u"
            else
                PS1="${PS1}\[${COLOR_LIGHTRED}\]\u"
            fi
        else                               
            PS1="${PS1}\[${COLOR_YELLOW}\]\u"
        fi
    else
        if [ ${USER} == ${LOGNAME} ]; then     
            PS1="${PS1}\[${COLOR_GREEN}\]\u"
        else                               
            PS1="${PS1}\[${COLOR_BROWN}\]\u"
        fi
    fi
 
    # HTTP Proxy var configured or not
    if [ -n "$http_proxy" ] ; then
        PS1="${PS1}\[${COLOR_GREEN}\]@"
    else                               
        PS1="${PS1}\[${COLOR_LIGHTRED}\]@"
    fi
 
    # Host
 
    if [[ ${SSH_CLIENT} ]] || [[ ${SSH2_CLIENT} ]]; then 
        SSH_FLAG=1
    fi
    if [ ${SSH_FLAG} -eq 1 ]; then 
       PS1="${PS1}\[${COLOR_CYAN}\]\h "
    elif [[ -n ${SESS_SRC} ]]; then 
        if [ "${SESS_SRC}" == "(:0.0)" ]; then 
        PS1="${PS1}\[${COLOR_GREEN}\]\h "
        else 
            local parent_process=`cat /proc/${PPID}/cmdline`
            if [[ "$parent_process" == "in.rlogind*" ]]; then
                PS1="${PS1}\[${COLOR_BROWN}\]\h "
            elif [[ "$parent_process" == "in.telnetd*" ]]; then 
                PS1="${PS1}\[${COLOR_YELLOW}\]\h "
            else
                PS1="${PS1}\[${COLOR_LIGHTRED}\]\h "
            fi
        fi
    elif [[ "${SESS_SRC}" == "" ]]; then
        PS1="${PS1}\[${COLOR_GREEN}\]\h "
    else                                 
        PS1="${PS1}\[${COLOR_RED}\]\h " 
    fi
 
    # Detached Screen Sessions
    local DTCHSCRN=$(screen -ls | grep -c Detach )
    if [ ${DTCHSCRN} -gt 2 ]; then
        PS1="${PS1}\[${COLOR_RED}\][scr:${DTCHSCRN}] "
    elif [ ${DTCHSCRN} -gt 0 ]; then
        PS1="${PS1}\[${COLOR_YELLOW}\][scr:${DTCHSCRN}] "
    fi
 
    # Backgrounded running jobs
    local BKGJBS=$(jobs -r | wc -l )
    if [ ${BKGJBS} -gt 2 ]; then
        PS1="${PS1}\[${COLOR_RED}\][bg:${BKGJBS}]"
    elif [ ${BKGJBS} -gt 0 ]; then
        PS1="${PS1}\[${COLOR_YELLOW}\][bg:${BKGJBS}] "
    fi
 
    # Stopped Jobs
    local STPJBS=$(jobs -s | wc -l )
    if [ ${STPJBS} -gt 2 ]; then
        PS1="${PS1}\[${COLOR_RED}\][stp:${STPJBS}]"
    elif [ ${STPJBS} -gt 0 ]; then
        PS1="${PS1}\[${COLOR_YELLOW}\][stp:${STPJBS}] "
    fi
 
    # Bracket {
    if [ ${UID} -eq 0 ]; then              
        if [ "${USER}" == "${LOGNAME}" ]; then 
            if [[ ${SUDO_USER} ]]; then
                PS1="${PS1}\[${COLOR_RED}\]"
            else
                PS1="${PS1}\[${COLOR_LIGHTRED}\]"
            fi
        else                               
            PS1="${PS1}\[${COLOR_YELLOW}\]"
        fi
    else                                 
        if [ "${USER}" == "${LOGNAME}" ]; then 
            PS1="${PS1}\[${COLOR_GREEN}\]"
        else                               
            PS1="${PS1}\[${COLOR_BROWN}\]"
        fi
    fi
    PS1="${PS1}{ "
 
    # Working directory
    if [ -w "${PWD}" ]; then 
        PS1="${PS1}\[${COLOR_GREEN}\]$(prompt_workingdir)"
    else                                 
        PS1="${PS1}\[${COLOR_RED}\]$(prompt_workingdir)"
    fi
 
    # Closing bracket } and $\#
    if [ ${UID} -eq 0 ]; then              
        if [ "${USER}" == "${LOGNAME}" ]; then 
            if [[ ${SUDO_USER} ]]; then
                PS1="${PS1}\[${COLOR_RED}\]"
            else
                PS1="${PS1}\[${COLOR_LIGHTRED}\]"
            fi
        else                               
            PS1="${PS1}\[${COLOR_YELLOW}\]"
        fi
    else                                 
        if [ "${USER}" == "${LOGNAME}" ]; then 
            PS1="${PS1}\[${COLOR_GREEN}\]"
        else                               
            PS1="${PS1}\[${COLOR_BROWN}\]"
        fi
    fi
    PS1="${PS1} }\$\[${COLOR_DEFAULT}\] "
}     
 
# Trim working dir to 1/4 the screen width
function prompt_workingdir () {
  local pwdmaxlen=$(($COLUMNS/4))
  local trunc_symbol="..."
  if [[ $PWD == $HOME* ]]; then
    newPWD="~${PWD#$HOME}" 
  else
    newPWD=${PWD}
  fi
  if [ ${#newPWD} -gt $pwdmaxlen ]; then
    local pwdoffset=$(( ${#newPWD} - $pwdmaxlen + 3 ))
    newPWD="${trunc_symbol}${newPWD:$pwdoffset:$pwdmaxlen}"
  fi
  echo $newPWD
}
 
# Determine what prompt to display:
# 1.  Display simple custom prompt for shell sessions started
#     by script.  
# 2.  Display "bland" prompt for shell sessions within emacs or 
#     xemacs.
# 3   Display promptcmd for all other cases.
 
function load_prompt () {
    # Get PIDs
    local parent_process=$(cat /proc/$PPID/cmdline | cut -d \. -f 1)
    local my_process=$(cat /proc/$$/cmdline | cut -d \. -f 1)
 
    if  [[ $parent_process == script* ]]; then
        PROMPT_COMMAND=""
        PS1="\t - \# - \u@\H { \w }\$ "
    elif [[ $parent_process == emacs* || $parent_process == xemacs* ]]; then
        PROMPT_COMMAND=""
        PS1="\u@\h { \w }\$ "
    else
        export DAY=$(date +%A)
        PROMPT_COMMAND=promptcmd
     fi 
    export PS1 PROMPT_COMMAND
}
 
load_prompt

Bonus – Finding the Right Colors

As you may have noticed, most of these prompts use color, and the color is often represented in a coded form like ‘\033[1;30m’, which is quite difficult to read or remember. An easy way to see all your available colors, and preview what they’ll look like, is to simply paste the following snippet into your browser:

for i in `seq 1 7 ; seq 30 48 ; seq 90 107 ` ; do 
    echo -e "\e[${i}mtest\e[0m$i" 
done

Which will output each color code with its number.

Conclusion

There are, of course infinite variations that could be packed into your prompt. Nearly any kind of textual data can be added in, and bash’s developers have had decades to add in functionality. Some readers have even commented about running custom Python or Ruby scripts from within the prompt. Whatever you do, make it functional, and if it’s REALLY cool, drop us a link in the comments!

The post More Useful and Interesting Bash Prompts appeared first on Make Tech Easier.

1. Fix Audio/Video/Subtitle Sync Problems

One of the most annoying things that can happen on video playback is when the audio and video tracks do not sync up properly. Sometimes it’s a result of bad encoding software, sometimes it’s a result of a mistake by the person doing the encoding, but it’s always annoying. VLC feels your pain and includes a tool to adjust the delay for the audio and/or subtitle tracks to let you adjust things as needed. Just open Tools -> Track Synchronization to make your adjustments.

2. Watermarks/Overlays

Sometimes you may need to place some text or watermark into your video display (particularly when transcoding), and you don’t need a video editor suite to accomplish this. VLC’s got that too. Like some of our other tips, this can be found in Tools -> Effects and Filters, but this time under the Video Effects tab under Vout/Overlay.

If you want a graphic instead of plain text, you can do that with the Logo tab in the same section.

3. Control Playback Through the Web

If you’ve got your videos hooked up to play through a home theater PC, or just like to do remote control, you can command VLC from anywhere through its network interfaces for Telnet or Web. Just open View -> Add Interface -> Web Interface. It starts a small web server (you may need to adjust your system firewall settings to allow it) which can be accessed on port 8080. The web interface will let you start, stop, and set current playback and even adjust volume just as if you were clicking the buttons on the player window itself.

4. Mouse Gestures

Many people find mouse gestures to be a more natural way to interact with a computer than using buttons, and VLC has got those people taken care of as well. If you’re not familiar with them, mouse gestures let you use various click-and-drag motions to tell the application what to do. In web browsers, for example, you might drag the mouse anywhere on the screen from right to left to go back, instead of moving up to the corner for the button. It may not sound like much but many mouse gesture users will say it adds up.

To enable this feature, go to View -> Add Interface -> Mouse Gestures. You may need to restart VLC for the changes to take effect. The list of supported gestures can be found here.

Conclusion

As always, VLC delivers more than expected from a media player. There have been times when this author has run into some type of problem with a video and thought “I bet VLC is clever enough to have something for this…” and most of the time, I’ve been right. In case you can’t tell, I’m a fan.

The post 4 More Things You Didn’t Know VLC Could Do appeared first on Make Tech Easier.

A bit about Crave Invoice

This is a Windows application and comes in three versions – Pro, Enterprise, and Ultimate. Each builds on the last, so where Pro includes invoicing along with customer and product management, Enterprise adds inventory management and Ultimate includes all of Enterprise plus a plugin for managing production.

All versions have a 30-day free trial where you can decide if you like the program before purchasing a license.

Setup

As a Windows program, it installs like any other, and you’re greeted on the first run with a brief 3-step wizard to enter company information and, optionally, tax and currency info.

As far as wizards go, this one’s quick and simple, and I appreciate that you can choose to skip the tax and currency screens once you’ve completed the initial company info screen.

Basic Usage

Of the three editions mentioned above, we’re reviewing the Pro edition. It is the most limited of the three, but it provides the core modules used by all editions and demonstrated the functionality of the program. Once you’re done with the First Run Setup Wizard, you’ll get the main application screen

which is pretty straighforward. The first thing I did was to try making a new customer, and this is where I ran into the first of a few “quirks” in the application. When creating my fictional customer I decided to enter a London, UK address to see how the application would handle a non-US address, and got the following response

In short, it’s telling me that I did not enter a ZIP code (not applicable in UK). It doesn’t like that I did not enter any information for delivery address (in the next tab over). Crave did accept a London-style postcode in the ZIP box, and I was able to set the delivery information to Same As Billing Address so this was not a deal-breaker, but I can’t predict how the system might respond to countries without a ZIP equivalent. As deliveries have nothing to do with my business, and many others, I was a bit surprised that the Delivery tab would be a required field.

Managing Products

To simplify your bookkeeping, you can specify individual products and their prices with Crave and easily add them to your invoices later. Just choose the Create New Product button from the Quick Access Panel.

While it’s one relatively small portion of the overall application, I actually had two complaints about this section. The first is the lack of a description field, or any other way to include additional info/comments/notes about a product. Second, the Units of Measure field provides four options – NOS, KGS, LTR, and MTR without any tooltip or other information about exactly what those mean. From the looks of it, I’d think those might mean number of units, kilograms, liters and meters but there’s no clarification in the GUI or even the online docs to confirm that. A Google search for those terms brought me to a Foreign Trade Department website which confirmed my suspicions, but the software shouldn’t necessarily assume I’m up on the latest FTD abbreviation standards.

Invoicing

Surely, if there’s one place this software should shine, it should be invoicing. Why else put that in the name? For the most part, I’d say it’s justified. Crave makes it easy to pull up customer and products and combine them into a simple-to-use invoice generator.

This screen contains all the invoice generation options I need (plus a few more) and is fairly straightforward and intuitive.

Once I finished entering my invoice details, I hit a snag which very nearly caused me to completely dismiss Crave as useless – until I realized it was another GUI “quirk”. If you look at the above screenshot, you might notice two important things missing. You can print, but there’s nothing to email your invoice, or export it to a file! All is not lost, however, as both those functions are present, but for some reason they’re both hidden behind the Print button. Click that, and you’ll see a preview window which DOES have the controls to email and export.

Conclusion

It’s hard to nail down a single, solid opinion about Crave Invoice. Its primary focus – creating simple and nice-looking invoices, it does well. The graphics are good, but there are some downright silly usability choices (such as loading all screens into one overlapping space with no tabs/tiling/other sane organization). There’s very good reporting capabilities, but the usability troubles make it difficult to want to take advantage of that. I suppose if I had to sum it all up, I’d say that Crave Invoice has some pretty impressive functionality, but lacks quite a bit in form. It appears to be designed for a somewhat limited type of business, but for that type (small manufacturing) it could be extremely useful, provided you can get past those quirks.

Free Giveaway

The developer of Crave Invoice has gladly sponsored 10 license keys to giveaway to all of you. Here is how you can participate:

Update: Contest Closed

[giveaway]Step 1:

Share this giveaway post in Facebook or Twitter.

Step 2
Leave a comment below with the link to the facebook/twitter post status. [/giveaway]

This giveaway begins now and ends Sunday, 4th September 2011 at 2359hrs Pacific Time. The winners will be selected at random and announced via email.

Share and enjoy!

Check out Crave Invoice.

MakeTechEasier would like to thank craveinvoice.com for their generosity in sponsoring this giveaway. Interested in sponsoring? We’d love to hear from you. Get in touch with us.

The post Crave Invoice Review + Free Giveaway [Update: Contest Closed] appeared first on Make Tech Easier.

Why Debian?

There are a few distributions out there, such as Puppy or Damn Small Linux which focus almost entirely on this niche. Why not use one of them? You certainly can, but Debian’s characteristics make it ideal as a platform for building up your software stack the way you want it. Debian’s greatest strength (though some might call it a weakness) is that it is not a unified, cohesive whole in the way that Windows, OSX, and even Ubuntu are. Instead, Debian is more like a box of Legos, where you’re provided with a solid base and access to all the pieces you need. This is what makes it such a popular starting point for custom Linux systems, and why it’s the core behind many of today’s most popular desktop Linux distributions.

Installing the Core System

Before we begin installing, it’s important to note that Debian install CDs are strictly composed of 100% free software. That means it does not contain any non-free hardware drivers, so there is a good chance that your laptop’s wireless network device will not function from the install media. Therefore it is highly recommended that you proceed with the installation using cabled Ethernet.

For many reasons, I suggest using the tiny Network Install CD instead of the full 700MB ISO. This will likely end up saving you a lot of time that would otherwise be wasted downloading and upgrading packages that you don’t want or need.

We’ve previously covered the process of performing a Debian network install, so I won’t go into detail here, but there is one important suggestion. Once the Software Selection screen comes up (after partitioning and such), I strongly recommend that you uncheck the box for Desktop Environment, and check Laptop.

You certainly can leave Desktop Environment checked if you wish, which will install a vanilla Gnome 2 desktop. I suggest removing it because that will add a LOT of weight to your install, and will most likely include several packages and services you do not need.

Post-Install Configuration

Getting the OS installed is only the first step. Now, let’s include some packages. Once you’ve booted up and logged in, you’ll probably want to start by installing your own graphical environment to replace Gnome. First, however, we’ll need to add a few core pieces that will be needed by any desktop software. Run the following command (as root) to add these core utilities.

apt-get install xorg sudo iceweasel pulseaudio

• X.org is the backend graphical system used by all major desktop environments
• sudo allows you to run individual commands as root
• Iceweasel is Debian’s 100% free rebranding of Firefox
• PulseAudio is one of the sound systems most commonly used in Linux*

* Some people have had a lot of trouble with PulseAudio, which can be difficult to get working properly. If you have trouble, try installing alsa-base and alsa-utils instead, which will make your system use the Advanced Linux Sound Architecture.

Once finished, make sure your username has sudo rights and you’re ready to install your desktop.

Option 1: LXDE

Based on OpenBox, LXDE is a very small and fast desktop environment. It includes several small applications such as a file manager terminal, and music player designed specifically for use in LXDE.

LXDE is well suited to those who want to get up and running right away, or those who are used to the Windows-style desktop and Start menu interface.

It can be installed easily from the command line with

sudo apt-get install lxde

Option 2: Window Maker

If you’re a little more adventurous, or a little more willing to tinker with settings, I very highly recommend Window Maker. It’s a bit old, it’s a bit ugly, but with a few tweaks, it becomes quite possibly the most productivity-oriented desktop around.

And it’s fast. Blazing fast. This entire article was written on an old HP laptop running Debian and Window Maker as described, and my desktop is more responsive than most of the higher-end Windows 7 and even Linux desktop running larger, fatter environments.

(This is, of course, a completely subjective statement and depends on a lot of variables)

Like LXDE, it’s easily installed from the command line with

sudo apt-get install wmaker

Software Suite

Presumably, by this point, you’ve got your lean and mean Debian system running with little more than a window manager and a web browser. I recommend the following applications for keeping productivity high and resource usage low.

• NDISWrapper Driver Tool – Allows you to use many Windows drivers to run devices on Linux (extremely handy for WiFi)
• PCManFM File Manager – Even if you’re not using LXDE, this is a great lightweight file manager that stays out of your way.
• Geany Code Editor – If you do software development, Geany is an excellent editor that has many useful features, but manages to remain small and fast.
• VLC Media Player – It doesn’t matter the distro or even the OS, VLC is just a great player.
• Audacious Music Player – This is one of the last remaining WinAmp style players, and still does a great job.
• LightDM – A desktop login manager intended as an alternative to large ones like GDM and KDM

Conclusion

Hopefully, by the time you’re done reading this, you’re well on your way to a custom Debian setup that allows your old laptop to run fast and smooth. I’ve toyed with many a Linux distribution and desktop environment, yet time after time I come back to Debian and Window Maker, with a few lightweight utilities. Together they make for fantastically productive and useful computing with minimal clutter. This laptop, for one, is never going to have to try to run Linux Mint again.

The post How to Build a Lightweight Linux for your Low-End Laptop appeared first on Make Tech Easier.

Installation

RSS Share for Google+ and Google Reader (henceforth referred to as RSS Share) is a Chrome/Chromium extension, so yes, you will need to be running Google’s browser. If you haven’t already tried Chrome, you may be surprised by the speed and simplicity of the UI.

The extension can be installed from this page. It’s a simple one-click install that should operate like any other Chrome extension.

What it Does

The features, as described by the developer, are as follows:

• “Share on Google+” button in Google Reader
• (Optional) Add Google Reader section to Google+
• Show read and unread RSS items on Google Plus
• Choose if read items are shown
• Instantly share any link
• Google Reader unread count on Google Plus
• j/k key bindings for scrolling through RSS items on Google Plus
• Infinite scrolling for RSS items
• Click on title to refresh unread count
• Tree view of feeds

Usage

First, if you have any Google+ or Reader tabs open, you’ll want to fully refresh them after the extension is installed to make sure the page is rendered with the new bits included. In Reader, you’ll now see a Share with Google+ option at the bottom of each post.

which will bring up the sharing interface familiar to any Google+ user.

That’s nice and all, but RSS Share actually has another trick up it’s sleeve, and it’s a good one. If you open up your Google+, you’ll see that you’ve now got a list of your feeds in the sidebar, under your stream options.

Clicking on any of the titles will bring up the feed in Google+.

Unfortunately, I have yet to find a way to post entries from Google+ to Reader, but I suppose when you consider that those items are in an entirely different format from RSS and have security and other considerations applied, it makes some technical sense.

Conclusion

It’s been this author’s experience that many similar extensions tend to feel clunky and tacked-on. RSS Share for Google+ and Google Reader is the first I’ve found that integrates seamlessly, and feels like it belongs in the base applications. There are times when such things seem useful at first but quickly get forgotten, but RSS Share is something I’ll be keeping around for a while.

The post How to Integrate Google Reader and Google+ appeared first on Make Tech Easier.

1. Audiotool - Music Creation

Ever wish you could play around with all that amazing gear some electronic musicians have? Audiotool gives you digital representations of synthesizers, drum machines, and effects pedals that you can combine and tweak in any way you wish. Each component is isolated, and it’s up to you as the user to connect them however you see fit.

Is it a full replacement for expensive hardware? Probably not, but it sure is a lot of fun.

2. Cloud9 - Software Development

One of the biggest hurdles to widespread adoption of the browser-based “cloud desktop” model (such as with Google’s Chromebooks) is the inability to do even simple software development. Much (though not all) of that can be solved with cleverly designed web apps such as Cloud9. It’s a multi-language IDE with many of the features you’d expect in a desktop code editor (tabs, syntax highlighting, etc) and a few neat features of its own, like GitHub integration.

It’s this author’s opinion that the GitHub integration is probably the most valuable feature of Cloud9. Not only can you sync up with the code in your GitHub repository, you can even use your normal GitHub credentials to log in to Cloud9.

3. Chrome Theme Creator – Browser Customization

We previously touched on ways to create Chrome themes, but this one based out of ChromeTheme.net has proven itself to be quite simple and capable. You can choose the colors and images you desire for your theme and once everything’s ready, just download the pack.

4. Flixster - Movie Reviews and Showtimes

If you’re a movie nut, this app from the infamous RottenTomatoes.com will likely keep you happy. It includes film details, trailers, reviews, an extensive rating system, and even helps you look up local showtimes.

5. 3DTin

A few years ago, the idea of a functional 3D modeling program inside a browser might have seemed pretty ridiculous. Through advances in technology (and the valiant efforts of standards boards) we’re now closer than ever to having our browsers as fully capable gaming platforms. 3DTin is a fine example of one way these new technologies can be used.

6. Angry Birds – Game

This list would not have been complete without at least one game, and when it comes to free Chrome games it’s hard to beat Angry Birds (though some would argue in favor of Plants vs Zombies). Chances are you’ve at least heard of this game – it’s shown up in commercials and movies and it’s even shown up during Rifftrax commentaries.

Conclusion

While many Chrome apps are indeed just links to existing independent web apps, the Chrome Web Store always provides an easy way to browse and rate them, and often provides something new. Perhaps it’s a free version of a paid app, perhaps it’s new features, perhaps it’s nothing. Whatever the details, Chrome Apps can be a great place to find the application you never knew you were looking for.

The post 6 More of the Coolest Chrome Web Apps appeared first on Make Tech Easier.

Get the app

Just about any Linux distribution with online repositories will have this package available, normally as just mpg123. Ubuntu users can find it in the Software Center or from the command line with

sudo apt-get install mpg123

In the event that your distribution does not have binaries available, you can download the source code here.

The Basics

A single track can be played in a simple and pretty obvious way, just mpg123 followed by the filename, as in:

mpg123 MySong.mp3

Which will play the single track from start to finish with output something like this:

Playlists

You can also use shell wildcards to send mpg123 several files at once. The simplest example is to use the above method, but replace the filename with a quick and easy *.mp3.

mpg123 *.mp3

To set your playlist to shuffle mode, just add a -Z in there

Optionally, you can use normal bash redirect characters to feed mpg123 a list of filenames.

ssh username@my-remote-machine-address
mpg123  -Z  -@  < myplaylistfile

The -@ flag tells mpg123 to treat the following input as a playlist (it’s the shortened form of –list), and the < is a standard bash redirect to pull the text out of the file and use it as mpg123‘s input.

Remote Play Control

This isn’t exactly a “feature” of mpg123, it’s more like a side effect, but for this author, it’s the most handy thing about this application. You see, regular readers or Linux pros probably already know about SSH, the fantastically useful remote shell application with 1001 uses. Since SSH gives you a shell on a remote machine, you can run programs on that remote machine. As mpg123 is just another shell application, the normal rules apply. If you SSH into a machine and run mpg123, it will play out that machine’s speakers.

This is great for me. If I’m sitting on the porch with my netbook on a fine summer day, I can SSH into my desktop (which is hooked up to a home theater) and run a mpg123 to start my music without ever leaving the chair, or being forced to deal with the low-quality underpowered netbook speakers. Just SSH into the machine and run mpg123 as if you were sitting at the keyboard, as in

ssh username@my-remote-machine-address
mpg123  -Z  --@  < myplaylistfile

Conclusion

If you like tag-based music libraries, album art, device synchronization, and other fancy features – mpg123 is clearly not a solution for you. In fact, I doubt there are many people who’d want to use this as their primary music player on a day-to-day basis, but there are certainly times when it comes in handy. We’ve explored just a few of them, and I’m sure our readers can come up with quite a few more. If you’ve found a great use for mpg123, please let us know in the comments.

The post How to Play MP3s From The Linux Command Line appeared first on Make Tech Easier.

1. OpenTTD

OpenTTD is a clone of the commercial game Transport Tycoon Deluxe. It’s extremely detailed, and has remained one of the highest rated Linux games of this type for years. You’re given a world that’s populated by several small towns, mines, factories, etc. Each of them is a source of supply or demand, and your job is to build an efficient and profitable transportation system to keep everyone happy.

The only thing that makes me reluctant to recommend OpenTTD is that it’s got a very high learning curve. Don’t expect to sit down the first time and just figure it out. Even a simple thing like connecting a mine to a factory with a rail line involves half a dozen steps involving multiple menus. The website does provide some info for help get started, and YouTube has a few helper videos as well.

2. Unknown Horizons

This is a great game that so far hasn’t received much attention. This is probably due to the fact that it’s still in Alpha status, and while its quite fun, it is still lacking some features, and comes with a very limited supply of game maps. As a player in Unknown Horizons, you try to colonize various pieces of land to produce new resources like wool, lumber, and liquor.

The downside here is that to the best of my knowledge, they have not yet implemented a “smart” AI to play against. Because of this, the game is fun, but only for a limited time. At some point, you’ve built and colonized all you want, and there’s essentially nothing left to do.

I mention this game because it’s got great potential, and I’m hoping some code-savvy readers might try it out and enjoy it enough to pitch in with development.

3. CorsixTH

CorsixTH is somewhere between a clone and a port of the commercial game Theme Hospital. In fact, to get the game running, you need at least some of the game files from Theme Hospital itself. Don’t let that stop you though, as most of those files can be acquired from the free demo, which is linked from the same page as the CorsixTH download.

The demo does not include ALL the files found in the normal game, so you may eventually come across something you can’t do without the original game files.

4. LinCity

In spite of the name, this is not actually a clone of SimCity, but it is certainly inspired by that game. The idea is quite similar, you build up a small villiage into a thriving metropolis. As your city grows, you unlock new ways to improve it. Even those unfamiliar with SimCity should be able to pick it up without much trouble, but learning to efficiently satisfy your citizens and your wallet can take a lot of practice.

The post 4 of the Best Economy Games for Linux appeared first on Make Tech Easier.

The Quick and Dirty Personal Scan

A common technique used by some malware authors is to replace a normal system binary with one that takes additional or alternative actions. Many of them try to protect themselves by making their corrupted versions immutable in an attempt to make the infection harder to remove. Fortunately, this leaves traces behind that can be picked up by normal system tools.

Use the lsattr command to display the attributes of your system’s binary files in locations such as /bin, /sbin, and /usr/bin, as shown here.

lsattr /usr/bin

Normal, non-suspicious output should look something like this.

You may need root privileges to scan some places like /sbin. If the output contains other attributes like s, i, or a, that could possibly be a sign that something is wrong, and you may wish to try a deeper scan as shown below.

Scanner #1 – Chkrootkit

Chkrootkit is a tool to scan your systems vital files to determine if any of them show signs of known malware. It’s a group of scripts that use existing system tools and commands to validate your system files and /proc information. Because of this, it’s recommended than it be run from a live CD, where there can be higher confidence that the base tools have not already been compromised. You can run it from the command line with just

# You might need "sudo" for root privileges
chkrootkit

but since chkrootkit does not create a log file by default, I’d recommend redirecting the output to a log file, like with

chkrootkit > mylogfile.txt

and when it finishes, just open up the log file in your text editor of choice.

Scanner #2 – Rootkit Hunter (rkhunter)

Rootkit Hunter acts a lot like chkrootkit, but bases much of its functionality on hash checks. The software includes known good SHA-1 hashes of common system files, and if it finds that yours differ, it will issue an error or warning as appropriate. Rootkit Hunter could also be called more thorough than chkrootkit, as it includes additional checks regarding network status, kernel modules and other pieces that chkrootkit does not scan.

To start a normal local scan, just run

# You might need "sudo" for root privileges
rkhunter -c

When it’s completed, you’ll be shown a summary with the results of your scan.

Rootkit Hunter does create a log file by default, and saves it to /var/log/rkhunter.log.

Conclusion

Be warned – both of these applications, as well as the “manual” method, may produce false positives. If you get a positive result, investigate it thoroughly before taking any action. Hopefully, one of these methods can help you identify a threat before it becomes a problem. If you’ve got any other suggestions for ways to detect nasty files or appliations, please let us know in the comments below.

Image credit: rykerstribe

The post How to Check for Rootkits on Linux, BSD, and OSX appeared first on Make Tech Easier.

Basic Differences

We already spent come time comparing Ubuntu 11.04 and Fedora 15, so I won’t dwell on that here. In short, both have decided to move beyond the traditional Gnome 2 desktop and move into hardware-accelerated modern setups. Ubuntu created Unity and aimed it squarely at casual computer users.

Ubuntu Unity

whereas Fedora bet their farm on Gnome 3, a newly redesigned and radically different Gnome desktop.

It’s certainly no secret that this author prefers Gnome 3, and that was a major factor in my decision to try Fedora. It’s among the first major distributions to put their full weight behind this relatively new project.

There are of course many differences between Ubuntu and Fedora, but this review will focus on the desktop user experience.

The Good

As mentioned above, the most noticeable difference between Fedora and Ubuntu, or even Fedora 15 compared to earlier versions, is that it now runs the Gnome 3 desktop. This is a near-complete rewrite of the Gnome interface and many of its underlying libraries. It takes advantage of hardware-based 3d acceleration to provide extraordinarily smooth effects when creating, destroying, or moving Windows. In fact, it’s this author’s opinion that Gnome 3 has mastered this aspect better than any other desktop interface from any operating system. There are no visual events at all in Gnome 3 that feel jerky or sudden – absolutely everything is smooth and cozy.

Next up for positive traits is the fact that Gnome 3 can be scripted and themed with… wait for it… JavaScript and CSS! This means that thousands of developers can immediately apply these popular web technologies to their desktop, customizing it any way they wish using skills they already possess.

The Bad

It’s new. It’s really new, and that has some consequences. Most notably, it means that Gnome 3 lacks a lot of the features users have come to expect from Gnome 2, such as integrated chat and social features and many system configuration options.

Regarding performance, that’s a little bit tricky. I am uncertain whether the problem is caused by Gnome itself, or perhaps some misbehaving application, but on my desktop (and I’m not the only one, judging by some posts I’ve found online) the system seems to get progressively slower the longer it’s used. It’s not normal to have to reboot a Linux system every day, especially to fix a problem like this, but until I’m able to determine the cause of the problem, I can’t rest the blame solely on Gnome.

One thing I can clearly define as a software problem is the apparent trouble Fedora has with saving my application preferences. Google Chrome is repeatedly insisting that it’s not the default browser, and Nautllus refuses to accept any changes to its application associations. No matter how many times I tell it to use VLC for video, it always defaults back to the built-in player next time Nautilus is opened. This is true for all file types I have attempted to change.

Regarding workspace management, I’m torn. The initial builds of Gnome Shell that we originally reviewed here used an excellent grid-based layout (similar to what you can do with Gnome 2 and Compiz) that I adored, and that alone was just about enough to make me fall in love with this desktop setup.

Later builds moved it to a linear approach, and eventually landed on an automatic linear approach. Personally I can’t stand it when my PC makes such decisions for me, so my first task was to set about learning how to disable that functionality.

If extensions were available allowing users to choose which workspace management method they prefer, this would instantly because one of Gnome 3′s killer features. It is my opinion that no other desktop environment offers matching workspace management capability. Unity is pretty good at that, but I’ve seen Gnome do better.

Conclusion

If I was to sum up my opinion on Fedora 15 in one sentence, it’d have to be “Rough, but with great potential“. Gnome 3 is still a baby, and Fedora took a bold step by pushing it to the forefront, and I applaud them for that. As cozy as it may be, there’s still a whole lot of polish left to be done. The front-end is still rough, and the back-end doesn’t seem to have yet caught up with all the changes. If Fedora can manage to take the successes in this release (which are many) and smooth out some of those rough spots (which are also many), then Fedora 16 is likely to pull a lot of users away from Ubuntu permanently. From the looks of it, I’ll be one of them.

Unity image credit – Andrew Currie

The post Living with Fedora – A Debian/Ubuntu User’s Take on Fedora 15 appeared first on Make Tech Easier.

The Extensions

The Gnome developers expected that users would want to customize the shell in unpredictable ways, so they made just about everything in the system extensible through JavaScript and CSS. I hope you web developers out there take notice of this, because it gives your desktop a LOT of potential. The extensions we’re going to be using here come from the Frippery pack, which can be downloaded here.

It contains more than just the ability to disable the auto workspace management, it’s intended to give back some features that Gnome 2 users might miss. There are additional extensions to add an Applications menu, Shutdown menu, and lower panel.

Fedora 15 users will find an RPM at the above link, other should be warned that the files in the tarball may not extract quite the way you’d expect. The compressed file contains not just a single directory with the extension files, but a full directory tree that expects to be extracted from your home directory, as shown here:

# If the file is in, say, your Downloads directory
cd Downloads
# Filename may vary
mv gnome-shell-frippery-0.2.3.tgz ~
cd
tar -zxvf gnome-shell-frippery-0.2.3.tgz

Activating/Deactivating Extensions

As mentioned earlier, there is an application called Gnome Tweak Tool that can provide a few configuration options. One feature is that it lets you easily activate and deactivate shell extensions. If your distribution natively supports Gnome 3 (such as Fedora 15), then you may be able to find it in your repositories.

If not, then you’ll have to do it manually. Use your normal package manager to install git, and then issue the following commands at your terminal:

git clone http://git.gnome.org/browse/gnome-tweak-tool
cd gnome-tweak-tool
./autogen.sh
make && sudo make install

If all goes well you should be able to launch the program and have full control over your extensions.

Regarding the auto-workspaces – if you want to set a specific number to remain permanently, you’ve got to first use the builtin Auto functionality to create them, and once you have the desired number, use the Tweak tool to disable it. Workpaces will no longer be added or removed by Gnome.

One Last Thing

While it serves its purpose, this is still a hack. It provides no way to add or remove manually, just enabling and disabling the Auto feature. Many Gnome Shell users, this author included, would love the option to use any of the previous workspace systems, as shown here. To me, all the earlier workspace management designs were more usable, particularly the original grid. This is my plea to the Gnome developers or any JavaScript gurus – since all those approaches have, at some point, been implemented in Gnome 3, could we please, pretty please, have them in the form of extensions?

The post How to Disable Automatic Workspaces in Gnome 3 (And Other Shell Tweaks) appeared first on Make Tech Easier.

Mappers/Viewers

Tectonicus

Tectonicus offers several impressive features, most notably the high-detail zoomable rendering and integration with Google Maps. With setup it can work with your server to show player location on the map in near real time, allowing you a virtual window into your world.

Be warned though. With all the detail and layers of zoomability, the initial rendering of the map is sloooooooowwwwww. On the Core 2 Duo test machine used for this article, it took almost 30 minutes for a fairly small map.

Minecraft X-Ray

A fine example of software that does one thing and does it well. Minecraft X-Ray lets you fly around, over and under your world. The particularly useful feature is that you can use the function keys to specify certain block types to highlight. These blocks will pulse with light, making it extremely easy to spot their locations.

Map Editors

MCEdit

While MCEdit’s interface takes some getting used to, it is undoubtedly a very useful map editor. It includes brushes for manual edits as well as 3D region selection for fills and clones. As a bonus, MCEdit also lets you edit a few of the properties of your world such as player location and spawn point.

To run MCEdit, you may need to also install PyGame and OpenGL bindings for Python. Ubuntu users can do this from the Software Center or from the command line with

sudo apt-get install python-pygame python-opengl

Unfortunately, MCEdit seems to be the only full featured map editor for Linux that supports the current map format (McRegion). If any readers are aware of another functional editor, please let us know in the comments!

Skinning

Novaskin

This is a web-based skin editor for Minecraft. Not only can you draw your own as needed, but it also includes a library of skins already made by other users. Everything from zombie suits to Star Trek uniforms is already there and can be used in your own game.

SkinEdit

Where Novaskin is the fancy new web skinner, SkinEdit is the tried-and-true local editor. You’re given a grid with pixel space for all body textures, and whatever you paint is immediately apparent on the comically running preview person.

SkinEdit hasn’t been updated in a while, but (so far) Minecraft’s skin system doesn’t seem to have changed in the mean time.

Player/Inventory Editors

InvGrid

This is a simple, no-nonsense approach to inventory control. Each toolbar and inventory slot is accounted for and you can set the value of each as you wish. The other tabs of the program allow you to define scripts and set game properties such as time of day and player position.

MCPlayerEdit

MCPlayerEdit, a console application, can do many of the same things the best GUI applications can do, and a bit more. With this application you can set bookmarked locations, change time of day, warp between zones, and of course edit your inventory.

Bonus – Minecraft Structure Planner

Ever start a new project, then realize partway through that it’s going to take a LOT more work than you expected? If so, you’ll probably appreciate the value in the Minecraft Structure Generator. This handy little tool does just what it says – it helps you plan out structures and keeps track of all the materials you’ll need to build it. It’s even got prebuilt templates for things like suspension bridges, domes, and mazes.

Conclusion

What we’ve included here is only a handful of the applications available to enhance this already great game. Combining several of them can let players accomplish amazing things. If you think we’ve missed any of the best utilities, or just want to show off some of your creations, sound off in the comments.

The post The 7 Best Minecraft Editors and Utilities for Linux appeared first on Make Tech Easier.

Hello World

It’s tradition to begin a new “language” by creating a simple script to output the words “Hello World!”. That’s easy enough, just open your favorite text editor and enter the following:

#!/bin/bash
echo Hello World!

With only two lines, it couldn’t be a whole lot simpler, but that first line, #!/bin/bash, may not be immediately obvious. The first two characters (often called a hashbang) are a special signal. It tells Linux that this script should be run through the /bin/bash shell, as opposed to the C shell or Korn shell or anything else you might have installed. Without it, there’s no easy way for Linux to tell exactly what type of shell script this is. A Python script, for example, would likely start with something like #!/usr/bin/python.

After that is just the echo statement, which prints the words after it to the terminal (technically, to standard output).

Running Your Script

As is often the case with Linux, there are multiple ways to do this job. The most basic way would be to call bash manually and feed it the script file, as in

#Filename can be anything, .sh is a common practice for shell scripts.
bash myscript.sh

Clever readers may be thinking “But wait, didn’t we put that hashbang thing in so it would know to use bash? Why did I have to run bash manually?” and the answer is “You didn’t“. At least, you wouldn’t have if we had taken a moment to make the script executable on its own.

In the previous example, we launched bash and sent it the script. Now we’ll save ourselves some future time by making the script executable so we dont need to run bash manually. That’s as easy as a single command.

chmod +x myscript.sh

And now it can be run with the filename directly.

Variables and Arguments

Variables in bash can be a little more confusing than some other scripting languages, partly because they sometimes need to be prefaced with a $ character and sometimes not – depending on what you’re doing. Take the following example.

PATH=$PATH:/home/josh/scripts

We refer to the same variable, PATH, two times. Once there’s no $, but the other time there is. There are a few ways that you can remember when a $ is appropriate, but this author uses a “talking” metaphor. If I’m talking TO the variable (such as assigning it a new value) I call it by the short name, in this case PATH. If I’m talking ABOUT a variable (such as getting its current value) it gets a more formal title ($PATH). The precise reasoning and inner workings of this design are beyond the scope of this guide, so just try to remember that you need to include a $ if you’re trying to fetch the information in a variable.

Now we’re going to use a variable in our script. Change the second line to look like the following:

#!/bin/bash
echo Hello $1!

And re-run your script, but this time include your name after the script name.

Bash auto-assigns certain variables for you, including a few such as $1, $2 etc which hold each of the arguments passed to the script. Variables can be reassigned and renamed any way you wish, so you could rewrite the previous script as

#!/bin/bash
 
firstname=$1
lastname=$2
 
echo Hello $firstname $lastname!

As you can see, there are no $ signs when assigning the value to the variable, but you do need them when pulling the info out.

Conditionals and Loops

No script could get very far without the ability to analyse or loop through data. The most common method of determining a course of action is to use the if statement. It works much like you’d expect – IF something THEN do stuff ELSE do something different. This example compares the string of characters that we stored in the variable firstname and compares it to some hardcoded text. If they match, it prints special output. Otherwise, it continues as normal.

#!/bin/bash
 
firstname=$1
lastname=$2
 
if [ "$firstname" == "Josh" ]
then
  echo "What a great name"
else
  echo Hello $firstname $lastname!
fi

Finally, the next core component is bash’s ability to loop over data. The normal looping mechanisms for bash are FOR, WHILE, and UNTIL. We’ll start with while, as it’s the simplest.

#!/bin/bash 
         counter=0
         #While the counter is less than 10, keep looping
         while [  $counter -lt 50 ]; do
             echo $counter
             let counter=counter+1 
         done

That example creates a counter variable, begins a while loop, and continues looping (and adding one to the counter) until it reaches the limit, in this case 50. Anything after the done statement will execute once the loop is complete.

UNTIL operates similarly, but as the reverse of WHILE. A while loop will continue as long as its expression is true (counter less than 50). The until loop takes the opposite approach, and would be written as

until [  $counter -gt 50 ]; do

In this example, “while less than 50″ and “until greater than 50″ will have nearly identical results (the difference being that one will include the number 50 itself, and the other will not. Try it out for yourself to see which one, and why.)

Conclusion

As stated above, it would take a lot more than a single Getting Started article to fully demonstrate the power of bash scripting. The pieces shown here can be seen as the core components of how bash operates, and should suffice to show you the basic principles behind shell scripting in Linux. If you really want to get into the guts and start making some great scripts, check out GNU’s official bash reference guide here. Happy scripting!

The post The Beginner Guide to Writing Linux Shell Scripts appeared first on Make Tech Easier.

Selecting the Right Photo

There’s nothing actually preventing you from using any photo you wish, but there are a few guidelines to follow if you want the effect to be somewhat realistic.

• Avoid clouds/sky as much as possible. A “miniature” cloud tends to ruin the illusion
• Keep distances simple. Too many objects floating in and out of the background will make the effect very difficult to achieve.
• If possible, avoid large people and animals. It won’t look like a small scale photo if you can see Grandma on the porch.

For this guide, we’re using this source photo.

This particular image was chosen because it shows some of the potential good aspects, as well as some complications. Before explaining those in detail, let’s apply the basic effect and see what happens.

The Focus Blur

The idea here is that the area you wish to emphasize is at a certain distance from the camera, and objects at other distances are out of focus. In our example image, this is pretty simple to plan out. With the building at the far side of the water as our focal point, we can assume that everything above it (the sky) and everything below it (the nearby boats) would be out of focus.

Still with me? Ok, here’s how we make that happen. What we’re going to do is use 2 layers of the same image, one crisp and one blurry, and use a layer mask to fade between them. If you haven’t used layer masks before, now’s a great time to learn because they’re incredibly useful in many ways.

First, duplicate your layer so that you’ve got two identical shots.

With the top layer selected, go to Filters -> Blur -> Gaussian Blur. Precisely what you enter here depends entirely on your image and the distances involved. You may need to use the Undo button extensively before your image is done. For mine, I’m going with 15, which puts my image here.

Right now the entire top layer is blurry, and the bottom layer is nice and sharp. What we need is for the area we want sharp to show through clearly, while the other areas fade into blurriness the further they get from focus.

The Gradient

On the blurry layer, right-click and choose Add Layer Mask. When prompted, choose White – Full Opacity.

Layer masks are great – you can use them to “draw” transparency or other effects onto a layer. A fully white mask means that the layer is completely opaque, and nothing of the lower layers can be seen beneath it. Any dark spots drawn on the mask become “holes” in the layer, allowing the lower layers to show through. This means we draw a gradient on the mask, and as a result, the blurry layer can be faded in or out, allowing us to see the sharp layer beneath.

Since the focal point of our sample image is near the center of the picture, we’re going to use a bi-linear gradient. Unlike a normal “linear” gradient, it will follow the line you drag and it will mirror that line on the opposite side.

With black as foreground color and white as background, make sure you have the layer mask selected and not the layer itself. If colors and selection are ready, drag a line from the focal point to the area that should be fully blurred, as shown here.

This creates a black bar in your layer mask, which fades at the edges. This makes anything within the bar nice and sharp (showing the bottom layer) and anything else can gradually fuzzier (the top layer). Aren’t masks great?

The Hard Part

That’s about as far as we can go with “automatic” tools. From here on out, it’s doing fine-touches to the layer mask to make it look right. Take the above screenshot for example. You can see between the two buildings to the house and trees beyond. They’re nice and sharp even though they’re far away. Compare that to the boats which are only a few feet from our focal point, yet they’re blurry. The crane is another example of something that should be in focus, but isn’t.

Now, your only option is to sit down and start messing with that mask to make each piece pop just the way you want it.

For some fine examples of tilt shift done right, check out http://www.smashingmagazine.com/2008/11/16/beautiful-examples-of-tilt-shift-photography/.

The post How to Create Tilt Shift Effect in Gimp appeared first on Make Tech Easier.

1. Making a Temporary Filesystem (Ramdisk)

There are several reasons to make a temporary RAM-based filesystem such as fast read/write times or to guarantee that the files will not persist after reboot. Making such a “fake” filesystem is easy, and just requires one command.

mount -t tmpfs tmpfs /mytemppartition -o size=1024m

Where /mytemppartion is the location you wish to mount (it must already exist) and 1024m is the desired size of the ramdisk.

2. Quickly Scheduling Commands

Linux pros almost certainly know the at command, it lets you set a specific time for a job to be run. You simply say what to do and when to do it, and at takes care of the rest. Its usage can be confusing for some, so here’s one common way of scheduling a task with at.

at 12:30 #Enter key
somecommandtorun
anothercommand
#ctrl-D

If you want to verify that it worked, you can easily list the sceduled jobs with

at -l

3. Re-run Previous Commands

Perhaps you ran a long complicated command, but forgot to preface it with sudo, or maybe you didn’t add some necessary options to the end. Instead of retyping the whole thing or going back through your shell history, you can use “double bangs” to represent your last command.

mkdir /etc/myDir
#Permission denied
sudo !!
#Success!

If you’re the type who tracks your command history numbers, you can use the same approach to recall any previous command by referencing its number:

4. Find the PID of a Process

If you need to kill a particular process but don’t have its PID, there’s a simple shortcut to find it – the pgrep command. It doesn’t do anything that can’t be done with a combination of ps and grep, but every little bit helps.

5. Find the Fastest Apt Mirror

Most Debian-derived distributions (but not Ubuntu) have access to a great tool that seems to go largely unnoticed. It’s called apt-spy, and its purpose is to scan the list of known Debian mirrors to find the fastest one for you.

apt-spy update
#This example will scan stable branch of 20 american mirrors for 30 seconds each
apt-spy -d stable -a America -e 20 -t 30

6. Show Listening Ports and their Processes

If you need to see what’s listening for connections on your system, and the processes handling those connections, the old trusty netstat tool is up to the job. Try

netstat -tlnp

to see just such a list.

7. SSH Without Passwords

Many people, such as this author, use SSH on a nearly constant basis. It’s a great tool, there’s no denying that, but having to constantly retype your passwords can get annoying. Instead, you can simply copy your (public) SSH information to the remote machine, allowing it to authenticate you without requiring your password, and all you need is a single command.

ssh-copy-id username@remote-machine

Conclusion

Obviously we’ve only begun to scratch the surface when it comes to useful CLI tools, but the ones listed here are a few of those that we at MTE consider indispensable. If you’ve got any favorite utilities that we forgot to mention, let us know in the comments below.

The post 7 Linux Shell Tips For Increased Productivity appeared first on Make Tech Easier.

1. Simple Conky

For people who prefer a clean, simple, minimalistic design Simple Conky is a great way to go. It’s one of the few listed here that includes unread mail notifications.

2. Cherries

Part of a greater cherry-themed graphics pack, this configuration doesn’t pack in loads of info, but what it does include, it handles beautifully. The full pack can be found here.

3. Conky Widget Script

Born from a desire to combine Lua scripting with Conky’s capabilities, this gorgeous setup can give you system information in a way that’s hard to beat when it comes to simple beauty. Setup/installation might be a little trickier here than with some of the other options, but the results can be well worth it.

4. Night Drive

Night Drive puts all the info into a single bar that resembles an automotive dashboard. CPU, RAM and the usual monitors are all present along with a music display widget on the far right.

5. Conky Colors

To date we’ve come across more than one Conky configuration that goes by this name, but the one we’d recommend is here. This pack comes in 3 flavors – default, Cairo, and Rings. The example shown here is Rings.

6. Bionic Conky

While not the most flexible of the bunch, Bionic Conky is clearly among the most visually interesting. Most Conky configurations are kept in a shaded box or left as floating text, but here the content is tightly coupled with the design. This makes for a gorgeous desktop if you continue the robotic theme, but it may lack the flexibility of some of the other options listed here.

7. Conky Ken

The most noticeable aspect of this design is the radial display on the left. Where a normal Conky config would display things like CPU and network usage in bar graph form, Ken changes the shading of the circles to indicate those changes.

Conclusion

Conky’s base capabilities make it fantastically useful, but a little extra software can take it to a new level of form and function. If you’re not already using Conky, now’s a great time to start. If you’re an old hand, then hopefully at least one of the above configurations can help you take that extra step toward the desktop of your dreams.

The post 7 Beautiful Conky Configurations for Your Linux Desktop appeared first on Make Tech Easier.