news aggregator

Michael Rooney: Easily sending postcards to your Kickstarter backers with Lob

Planet Ubuntu - Tue, 2014-04-22 12:00

Recently my friend Joël Franusic was stressing out about sending postcards to his Kickstarter backers and asked me to help him out. He pointed me to the excellent service Lob.com, which is a very developer-friendly API around printing and mailing. We quickly had some code up and running that could take a CSV export of Kickstarter campaign backers, verify addresses, and trigger the sending of customizable, actual physical postcards to the backers.

We wanted to share the project such that it could help out other Kickstarter campaigns, so we put it on Github: https://github.com/mrooney/kickstarter-lob.

Below I explain how to install and use this script to use Lob to send postcards to your Kickstarter backers. The section after that explains how the script works in detail.

Using the script to mail postcards to your backers

First, you’ll need to sign up for a free account at Lob.com, then grab your “Test API Key” from the “Account Details” section of your account page. At this point you can use your sandbox API key to test away free of charge and view images of any resulting postcards. Once you are happy with everything, you can plug in credit card details and start using your “Live” API key. Second, you’ll need an export from Kickstarter for the backers you wish to send postcards to.

Now you’ll want to grab the kickstarter-lob code and get it set.

These instructions assume that you’re using a POSIX compatible operating system like Mac OS X or Linux. If you’re using Mac OS X, open the “Terminal” program and type the commands below into it to get started:

git clone https://github.com/mrooney/kickstarter-lob.git cd kickstarter-lob sudo easy_install pip # (if you don’t have pip installed already) pip install -r requirements.txt cp config_example.json config.json open config.json

At this point, you should have a text editor open with the configuration information. Plug in the correct details, making sure to maintain quotes around the values. You’ll need to provide a few things besides an API key:

  • A URL of an image or PDF to be used for the front of the postcard.
    This means that you need to have your PDF available online somewhere. I suggest using Amazon’s S3 service to host your PDF.

  • A message to be printed on the back of the postcard (the address of the receiver will automatically show up here as well).

  • Your return address.

Now you are ready to give it a whirl. Run it like so. Make sure you include the filename for your Kickstarter export:

$ python kslob.py ~/Downloads/your-kickstarter-backer-report.csv Fetching list of any postcards already sent... Verifying addresses of backers... warning: address verification failed for jsmith@example.com, cannot send to this backer. Already sent postcards to 0 of 161 backers Send to 160 unsent backers now? [y/N]: y Postcard sent to Jeff Bezos! (psc_45df20c2ade155a9) Postcard sent to Tim Cook! (psc_dcbf89cd1e46c488) ... Successfully sent to 160 backers with 0 failures

The script will verify all addresses, and importantly, only send to addresses not already sent to. The script queries Lob to keep track of who you’ve already sent a postcard to; this important feature allows you to download new Kickstarter exports as people fill in or update their addresses. After downloading a new export from Kickstarter, just run the script against the new export, and the script will only send postcards to the new addresses.

Before anything actually happens, you’ll notice that you’re informed of how many addresses have not yet received postcards and prompted to send them or not, so you can feel assured it is sending only as many postcards as you expect.

If you were to run it again immediately, you’d see something like this:

$ python kslob.py ~/Downloads/your-kickstarter-backer-report.csv Fetching list of any postcards already sent... Verifying addresses of backers... warning: address verification failed for jsmith@example.com, cannot send to this backer. Already sent postcards to 160 of 161 backers SUCCESS: All backers with verified addresses have been processed, you're done!

After previewing your sandbox postcards on Lob’s website, you can plug in your live API key in the config.json file and send real postcards at reasonable rates.

How the script works

This section explains how the script actually works. If all you wanted to do is send postcards to your Kickstarter backers, then you can stop reading now. Otherwise, read on!

Before you get started, take a quick look at the “kslob.py” file on GitHub: https://github.com/mrooney/kickstarter-lob/blob/master/kslob.py

We start by importing four Python libraries: “csv”, “json”, “lob”, and “sys”. Of those four libraries, “lob” is the only one that isn’t part of Python’s standard library. The “lob” library is installed by using the “pip install -r requirements.txt” command I suggest using above. You can also install “lob-python” using pip or easy_install.

#!/usr/bin/env python import csv import json import lob import sys

Next we define one class named “ParseKickstarterAddresses” and two functions “addr_identifier” and “kickstarter_dict_to_lob_dict”

“ParseKickstarterAddresses” is the code that reads in the backer report from Kickstarter and turns it into an array of Python dictionaries.

class ParseKickstarterAddresses:    def __init__(self, filename):        self.items = []        with open(filename, 'r') as csvfile:            reader = csv.DictReader(csvfile)            for row in reader:                self.items.append(row)

The “addr_identifier” function takes an address and turns it into a unique identifier, allowing us to avoid sending duplicate postcards to backers.

def addr_identifier(addr):    return u"{name}|{address_line1}|{address_line2}|{address_city}|{address_state}|{address_zip}|{address_country}".format(**addr).upper()

The “kickstarter_dict_to_lob_dict” function takes a Python dictionary and turns it into a dictionary we can give to Lob as an argument.

def kickstarter_dict_to_lob_dict(dictionary):    ks_to_lob = {'Shipping Name': 'name',                 'Shipping Address 1': 'address_line1',                 'Shipping Address 2': 'address_line2',                 'Shipping City': 'address_city',                 'Shipping State': 'address_state',                 'Shipping Postal Code': 'address_zip',                 'Shipping Country': 'address_country'}    address_dict = {}    for key in ks_to_lob.keys():        address_dict[ks_to_lob[key]] = dictionary[key]    return address_dict

The “main” function is where the majority of the logic for our script resides. Let’s cover that in more detail.

We start by reading in the name of the Kickstarter backer export file. Loading our configuration file (“config.json”) and then configuring Lob with the Lob API key from the configuration file:

def main():    filename = sys.argv[1]    config = json.load(open("config.json"))    lob.api_key = config['api_key']

Next we query Lob for the list of postcards that have already been sent. You’ll notice that the “processed_addrs” variable is a Python “set”, if you haven’t used a set in Python before, a set is sort of like an array that doesn’t allow duplicates. We only fetch 100 results from Lob at a time, and use a “while” loop to make sure that we get all of the results.

print("Fetching list of any postcards already sent...") processed_addrs = set() postcards = [] postcards_result = lob.Postcard.list(count=100) while len(postcards_result):    postcards.extend(postcards_result)    postcards_result = lob.Postcard.list(count=100, offset=len(postcards))

One we fetch all of the postcards, we print out how many were found:

print("...found {} previously sent postcards.".format(len(postcards)))

Then we iterate through all of our results and add them to the “processed_addrs” set. Note the use of the “addr_identifier” function, which turns each address dictionary into a string that uniquely identifies that address.

for processed in postcards:    identifier = addr_identifier(processed.to.to_dict())    processed_addrs.add(identifier)

Next we set up a bunch of variables that will be used later on, variables with configuration information for the postcards that Lob will send, the addresses from the Kickstarter backers export file, and variables to keep track of who we’ve sent postcards to and who we still need to send postcards to.

postcard_from_address = config['postcard_from_address'] postcard_message = config['postcard_message'] postcard_front = config['postcard_front'] postcard_name = config['postcard_name'] addresses = ParseKickstarterAddresses(filename) to_send = [] already_sent = []

At this point, we’re ready to start validating addresses, the code below loops over every line in the Kickstarter backers export file and uses Lob to see if the address is valid.

print("Verifying addresses of backers...") for line in addresses.items:     to_person = line['Shipping Name']     to_address = kickstarter_dict_to_lob_dict(line)     try:         to_name = to_address['name']         to_address = lob.AddressVerify.verify(**to_address).to_dict()['address']         to_address['name'] = to_name     except lob.exceptions.LobError:         msg = 'warning: address verification failed for {}, cannot send to this backer.'         print(msg.format(line['Email']))         continue

If the address is indeed valid, we check to see if we’ve already sent a postcard to that address. If so, the address is added to the list of addresses we’ve “already_sent” postcards to. Otherwise, it’s added to the list of address we still need “to_send” postcards to.

if addr_identifier(to_address) in processed_addrs:     already_sent.append(to_address) else:     to_send.append(to_address)

Next we print out the number of backers we’ve already sent postcards to and check to see if we need to send postcards to anybody, exiting if we don’t need to send postcards to anybody.

nbackers = len(addresses.items) print("Already sent postcards to {} of {} backers".format(len(already_sent), nbackers)) if not to_send:     print("SUCCESS: All backers with verified addresses have been processed, you're done!")     return

Finally, if we do need to send one or more postcards, we tell the user how many postcards will be mailed and then ask them to confirm that those postcards should be mailed:

query = "Send to {} unsent backers now? [y/N]: ".format(len(to_send), nbackers) if raw_input(query).lower() == "y":     successes = failures = 0

If the user enters “Y” or “y”, then we start sending postcards. The call to Lob is wrapped in a “try/except” block. We handle calls to the Lob library that return a “LobError” exception, counting those calls as a “failure”. Other exceptions are not handled and will result in the script exciting with that exception.

for to_address in to_send:     try:         rv = lob.Postcard.create(to=to_address, name=postcard_name, from_address=postcard_from_address, front=postcard_front, message=postcard_message)         print("Postcard sent to {}! ({})".format(to_address['name'], rv.id))         successes += 1     except lob.exceptions.LobError:         msg = 'Error: Failed to send postcard to Lob.com'         print("{} for {}".format(msg, to_address['name']))         failures += 1

Lastly, we print a message indicating how many messages were sent and how many failures we had.

    print("Successfully sent to {} backers with {} failures".format(successes, failures)) else:

(If the user pressed a key other than “Y” or “y”, this is the message that they’ll see)

print("Okay, not sending to unsent backers.")

And there you have it, a short script that uses Lob to send postcards to your Kickstarter backers, with code to only send one postcard per address, that gracefully handles errors from Lob.

I hope that you’ve found this useful! Please let us know of any issues you encounter on Github, or send pull requests adding exciting new features. Most importantly, enjoy easily bringing smiles to your backers!

The Fridge: Ubuntu Weekly Newsletter Issue 364

Planet Ubuntu - Mon, 2014-04-21 21:30

Welcome to the Ubuntu Weekly Newsletter. This is issue #364 for the week April 14 – 20, 2014, and the full version is available here.

In this issue we cover:

The issue of The Ubuntu Weekly Newsletter is brought to you by:

  • Elizabeth Krumbach Joseph
  • Paul White
  • Emily Gonyer
  • Tiago Carrondo
  • Jose Antonio Rey
  • Jim Connett
  • And many others

If you have a story idea for the Weekly Newsletter, join the Ubuntu News Team mailing list and submit it. Ideas can also be added to the wiki!

Except where otherwise noted, content in this issue is licensed under a Creative Commons Attribution 3.0 License BY SA Creative Commons License

Michael Hall: Make Android apps Human with NDR

Planet Ubuntu - Mon, 2014-04-21 18:54

Ever since we started building the Ubuntu SDK, we’ve been trying to find ways of bringing the vast number of Android apps that exist over to Ubuntu. As with any new platform, there’s a chasm between Android apps and native apps that can only be crossed through the effort of porting.

There are simple solutions, of course, like providing an Android runtime on Ubuntu. On other platforms, those have shown to present Android apps as second-class citizens that can’t benefit from a new platform’s unique features. Worse, they don’t provide a way for apps to gradually become first-class citizens, so chasm between Android and native still exists, which means the vast majority of apps supported this way will never improve.

There are also complicates solutions, like code conversion, that try to translate Android/Java code into the native platform’s language and toolkit, preserving logic and structure along the way. But doing this right becomes such a monumental task that making a tool to do it is virtually impossible, and the amount of cleanup and checking needed to be done by an actual developer quickly rises to the same level of effort as a manual port would have. This approach also fails to take advantage of differences in the platforms, and will re-create the old way of doing things even when it doesn’t make sense on the new platform.

NDR takes a different approach to these, it doesn’t let you run our Android code on Ubuntu, nor does it try to convert your Android code to native code. Instead NDR will re-create the general framework of your Android app as a native Ubuntu app, converting Activities to Pages, for example, to give you a skeleton project on which you can build your port. It won’t get you over the chasm, but it’ll show you the path to take and give you a head start on it. You will just need to fill it in with the logic code to make it behave like your Android app. NDR won’t provide any of logic for you, and chances are you’ll want to do it slightly differently than you did in Android anyway, due to the differences between the two platforms.

To test NDR during development, I chose the Telegram app because it was open source, popular, and largely used Android’s layout definitions and components. NDR will be less useful against apps such as games, that use their own UI components and draw directly to a canvas, but it’s pretty good at converting apps that use Android’s components and UI builder.

After only a couple days of hacking I was able to get NDR to generate enough of an Ubuntu SDK application that, with a little bit of manual cleanup, it was recognizably similar to the Android app’s.

This proves, in my opinion, that bootstrapping an Ubuntu port based on Android source code is not only possible, but is a viable way of supporting Android app developers who want to cross that chasm and target their apps for Ubuntu as well. I hope it will open the door for high-quality, native Ubuntu app ports from the Android ecosystem.  There is still much more NDR can do to make this easier, and having people with more Android experience than me (that would be none) would certainly make it a more powerful tool, so I’m making it a public, open source project on Launchpad and am inviting anybody who has an interest in this to help me improve it.

Rick Spencer: Adding Interactivity to a Map with Popovers

Planet Ubuntu - Mon, 2014-04-21 15:30
On Friday I started my app "GetThereDC". I started by adding the locations of all of the Bikeshare stations in DC to a map. Knowing where the stations are is great, but it's a bummer when you go to a station and there are no bikes, or there are no empty parking spots. Fortunately, that exact information is in the XML feed, so I just need a way to display it.  
The way I decided to do it is to make the POI (the little icons for each station on the map) clickable, and when the user clicks the POI to use the Popover feature in the Ubuntu Components toolkit to display the data.
Make the POI Clickable When you want to make anyting "clickable" in QML, you just use a MouseArea component. Remember that each POI is constructed as a delegate in the MapItemView as an Image component. So all I have to do is add a MouseArea inside the Image and respond to the Click event. So, not my image looks like this:
sourceItem: Image
{
id: poiImage
width: units.gu(2)
height: units.gu(2)
source: "images/bike_poi.png"
MouseArea
{
anchors.fill: parent
onClicked:
{
print("The POI was clicked! ")
}
}
}
This can be used anywhere in QML to make an image respond to a click. MouseArea, of course, has other useful events as well, for things like onPressed, onPressAndHold, etc...
Add the Roles to the XmlListModel I already know that I'll want something to use for a title for each station, the address, as well as the number of bikes and the number of parking slots. Looking at the XML I can see that the "name" property is the address, so that's a bonus. Additionally, I can see the other properties I want are called "nbBikes" and "nbEmptyDocks". So, all I do is add those three new roles to the XmlListModel that I constructed before:
XmlListModel
{
id: bikeStationModel
source: "https://www.capitalbikeshare.com/data/stations/bikeStations.xml"
query: "/stations/station"
XmlRole { name: "lat"; query: "lat/string()"; isKey: true }
XmlRole { name: "lng"; query: "long/string()"; isKey: true }
XmlRole {name: "name"; query: "name/string()"; isKey: true}
XmlRole {name: "available"; query: "nbBikes/string()"; isKey: true}
XmlRole {name: "freeSlots"; query: "nbEmptyDocks/string()"; isKey: true}
}
Make a Popover Component The Ubuntu SDK offers some options for displaying additional information. In old school applications these might be dialog boxes, or message boxes. For the purposes of this app, Popover looks like the best bet. I suspect that over time the popover code might get a little complex, so I don't want it to be too deeply nested inside the MapItemView, as the code will become unwieldy. So, instead I decided to add a file called BikeShareStationPopover.qml to the components sub-directory. Then I copy and pasted the sample code in the documentation to get started. 

To make a popover, you start with a Component tag, and then add a popover tag inside that. Then, you can put pretty much whatever you want into that Popover. I am going to go with a Column and use ListItem components because I think it will look nice, and it's the easiest way to get started. Since I already added the XmlRoles I'll just use those roles in the construction of each popover. 

Since I know that I will be adding other kinds of POI, I decided to add a Capital Bike Share logo to the top of the list so users will know what kind of POI they clicked. I also added a close button just to be certain that users don't get confused about how to go back to the map. So, at the end of they day, I just have a column with ListItems:
import QtQuick 2.0
import Ubuntu.Components 0.1
import Ubuntu.Components.ListItems 0.1 as ListItem
import Ubuntu.Components.Popups 0.1
Component
{
id: popoverComponent
Popover
{
id: popover
Column
{
id: containerLayout
anchors
{
left: parent.left
top: parent.top
right: parent.right
}
ListItem.SingleControl
{
control: Image
{
source: "../images/CapitalBikeshare_Logo.jpg"
height: units.gu(5)
width: units.gu(5)
}
}
ListItem.Header { text: name}
ListItem.Standard { text: available + " bikes available" }
ListItem.Standard { text: freeSlots + " parking spots available"}
ListItem.SingleControl
{
highlightWhenPressed: false
control: Button
{
text: "Close"
onClicked: PopupUtils.close(popover)
}
}
}
}
Make the Popover Component Appear on ClickSo, now that I made the component code, I just need to add it to the MapItemView and make it appear on click. So, I add the tag and give it an id to the MapQuickItem Delegate, and change the onClicked handler for the MouseArea to open the popover:
delegate: MapQuickItem
{
id: poiItem
coordinate: QtPositioning.coordinate(lat,lng)
anchorPoint.x: poiImage.width * 0.5
anchorPoint.y: poiImage.height
z: 9
sourceItem: Image
{
id: poiImage
width: units.gu(2)
height: units.gu(2)
source: "images/bike_poi.png"
MouseArea
{
anchors.fill: parent
onClicked:
{
PopupUtils.open(bikeSharePopover)
}
}
}
BikeShareStationPopover
{
id: bikeSharePopover
}
}
And when I run the app, I can click on any POI and see the info I want! Easy!

Code is here

Mario Limonciello: Ambilight clone using Raspberry Pi

Planet Ubuntu - Mon, 2014-04-21 05:39
Recently I came across www.androidpolice.com/2014/04/07/new-app-huey-synchronizes-philips-hue-lights-with-your-movies-and-tv-shows-for-awesome-ambient-lighting-effects/ and thought it was pretty neat.  The lights were expensive however, and it required your phone or tablet to be in use every time you wanted to use it which seemed sub-optimal.

I've been hunting for a useful project to do with my Raspberry Pi, and found out that there were two major projects centered around getting something similar setup.

Ambi-TV: https://github.com/gkaindl/ambi-tv
Hyperion: https://github.com/tvdzwan/hyperion/wiki

I set out to put a similar setup together for my TV.  I purchased:

Hardware SetupOnce everything arrived, I soldered a handful of wires to a prototyping board so that I could house more of the pieces in the raspberry pi case.  I used a cut up micro USB cord to provide power from the 5V rail and ground to the pi itself and then also to one end of the 4 pin JST adapter.  The same 5V 10a power supply is used to power both of them.
Prototyping board, probably this size is overkill,
but I have flexibility for future projects to add on now.

Once I got everything put into the pi properly, I double checked all the connections and closed up the case.
My pi case with the top removed and an
inset put in for holding the proto boardWhole thing assembledI proceeded to do the TV.  I have a 46" set, which works out to 18 LEDs on either side and 30 LEDs on the top and bottom.  I cut up the LED strips and used double sided tape to affix to the TV.  Once the LED strips are cut up you have to solder 4 pins from the out end of one strip to the in end of another strip.  I'd recommend looking for some of the prebuilt L corner strips if you do this.  I didn't use them and it was a pain to strip and hold such small wires in place to solder in the small corners.

Back of TV w/ LEDs attached
Corner with wires soldered on
Software SetupOnce all the HW was together I proceeded to get the software set up.  I originally had an up to date version of raspbian wheezy installed.  It included an updated kernel (version 3.10).  I managed to set everything up using it except the grabber, but then discovered that there were problems with the USB grabber.  Plugging it in causes the box to kernel panic.  The driver for the USB grabber has made it upstream in kernel version 3.11, so I expected it should be usable in 3.10 with some simple backporting tweaks, but didn't narrow it down entirely.
I did find out that kernel 3.6.11 did work with an earlier version of the driver however, so I re-did my install using an older snapshot of raspbian.  I managed to get things working there, but would like to iron out the problems causing a kernel panic at some point.
USB Grabber instructionsThe USB grabber I got is dirt cheap but not based off the really common chipsets already supported in the kernel with the versions in raspbian, so it requires some extra work.
  1. Install Raspbian snapshot from 2013-07-26.  Configure as desired.
  2. git clone https://github.com/gkaindl/ambi-tv.git ambi-tv
  3. cd ambi-tv/misc && sudo sh ./get-kernel-source.sh
  4. cd usbtv-driver && make
  5. sudo mkdir /lib/modules/3.6.11+/extra
  6. sudo cp usbtv.ko /lib/modules/3.6.11+/extra/
  7. sudo depmod -a
Hyperiond InstructionsAfter getting the grabber working, installing hyperion is a piece of cake.  This will set up hyperiond to start on boot.
  1. wget -N https://raw.github.com/tvdzwan/hyperion/master/bin/install_hyperion.sh
  2. sudo sh ./install_hyperion.sh
  3. Edit /etc/modprobe.d/raspi-blacklist.conf using nano.  Comment out the line with blacklist spi-bcm2708
  4. sudo reboot
Hyperion configuration fileFrom another PC that has java (OpenJDK 7 works on Ubuntu 14.04)
  1. Visit https://github.com/tvdzwan/hyperion/wiki/configuration and fetch the jar file.
  2. Run it to configure your LEDs.
  3. From the defaults, I particularly had to change the LED type and the number of LEDs around the TV.
  4. My LEDs were originally listed at RGB but I later discovered that they are GRB.  If you encounter problems later with the wrong colors showing up, you can change them here too.
  5. Save the conf file and scp it into the /etc directory on your pi
  6. sudo /etc/init.d/hyperiond restart
Test the LED's
  1. Plug in the LEDs and install the test application at https://github.com/tvdzwan/hyperion/wiki/android-remote
  2. Try out some of the patterns and color wheel to make sure that everything is working properly.  It will save you problems later diagnosing grabber problems if you know things are sound here (this is where I found my RGB/GRB problem).
Test pattern
Set up things for Hyperion-V4L2I created a script in ~ called toggle_backlight.sh.  It runs the V4L2 capture application and sets the LEDs accordingly.  I can invoke it again to turn off the LEDs.  As a future modification I intend to control this with my harmony remote or some other method.  If someone comes up with something cool, please share.
#!/bin/shARG=toggleif [ -n "$1" ]; then        ARG=$1fiRUNNING=$(pgrep hyperion-v4l2)if [ -n "$RUNNING" ]; then        if [ "$ARG" = "on" ]; then                exit 0        fi        pkill hyperion-v4l2        exit 0fihyperion-v4l2 --crop-height 30 --crop-width 10 --size-decimator 8 --frame-decimator 2 --skip-reply --signal-threshold 0.08&
That's the exact script I use to run things.  I had to modify the crop height from the defaults that were on the directions elsewhere to avoid flicker on the top.  To diganose problems here, I'd recommend using the --screenshot argument of hyperion-v4l2 and examining output.
Once you've got it good, add it to /etc/rc.local to start up on boot:
su pi -c /home/pi/toggle_backlight.sh
Test It all togetherEverything should now be working.
Here's my working setup:
https://www.youtube.com/watch?v=nSrGfh8asgg

Lubuntu Blog: Lubuntu 14.04

Planet Ubuntu - Sun, 2014-04-20 19:52
First of all, my apologies for disappear due to personal reasons (went out for a few days). But it's here, Lubuntu 14.04 codename Trusty Tahr. The missing links for PowerPC machines have been recovered. Feel free to go to the Downloads section and grab it. If you need more info check the release page.

Ubuntu Classroom: Ubuntu Open Week for Trusty: Starting Soon!

Planet Ubuntu - Sun, 2014-04-20 03:15

And the Ubuntu Open Week for this cycle is just around the corner! This will be three days full of excitement, where you will be able to know what different teams and people in the community do. Whether you are a developer, a designer, a tester or a community member, this is the right event if you want to get involved with the community and are looking for a starting point.

The event will take place from April 22nd to April 24th 2014, from 15 to 19 UTC each day. During these three days we will have people from various teams, such as the Server, Documentation, and Juju teams. There are twelve different sessions scheduled, so make sure to find which ones interest you and write the times down in your calendars! The full schedule can be found at the Open Week Wiki page.

All sessions will take place at #ubuntu-classroom and #ubuntu-classroom-chat on irc.freenode.net (click here to join from your web browser). There are three sessions in the schedule which are labeled with the [ON AIR!] tag, which means the session will be streamed live at the Ubuntu on Air! webpage.

In the case you can not attend the event, logs will be linked in the schedule as soon as they become available. For On Air! sessions, they will be available at the Ubuntu on Air! YouTube Channel. Hope to see you all there!


Valorie Zimmerman: Weeeee, Kubuntu 14.04 is out! and already looking to the future

Planet Ubuntu - Sat, 2014-04-19 22:35
The past week has been exhilarating and exhausting for our Kubuntu crew. I'm sure the other *buntu teams were working just as hard. Not just packaging, because that goes on all the time, though not at this intense pace. But the attention to detail, the testing, polishing, patching, discussion with developers to get those patches upstream, coordination with Debian, cleaning up copyright files, man pages and other documentation, making screen shots, our user docs and new website, more testing, more polish.... it was truly an amazing effort.

I used `ubuntu-bug` from the cli more than I ever have before, testing out the betas. It was an amazing experience to file the bug, and then see it fixed within the day! This happened again and again. The entire Ubuntu ecosystem really works well together. My thanks to those developers who read and respond to those bug reports.

What I love about Kubuntu is how everyone pitches in. All of us try to maintain balance in our lives, so that there is time for leisure and enrichment, along with work. Also, the work is fun, because the team enjoys one another, posting fun links, joking around, but continuing to work away on our todo lists. Even those who didn't have time for packaging, often stopped by the devel channel to find out what needed testing. It all helped!

Since I'm not a devel, all this was inspiring rather than exhausting. So I had the time and energy to spend time helping out folks with questions and trouble in #kubuntu and #kde. That felt great! We were able to answer most of the questions, and overcome most of the difficulties.

One issue that came up quite a few times in the last couple of days, was PPAs. On a clean install, of course all old PPAs are blown away. On an upgrade, however, they can linger and cause lots of perplexing problems. Official PPAs like backports are fine, but specialty ones should be removed before upgrading. If you need them, you can always re-add after the upgrade. For the same reason, unpin any packages you have pinned.

It is really fabulous to be able to present the latest KDE software into our Kubuntu LTS. This will give us the freedom to try out the newest stuff from KDE based on the sparkly new Frameworks, Plasma Next and so forth, in our next release. So, our users will be able to use software supported for five years if they want, while also having the option to install 14.10 (if all goes well) and check out the newest.

Sergio Meneses: Ubuntu and Canonical will be present in the Ubucon LatinAmerica

Planet Ubuntu - Sat, 2014-04-19 17:57

UbuconLA is happy to announce that Canonical and the Ubuntu Community will be sponsors in this version 2014.

Also, the Ubuntu Community will be present in the event with members from Spain, India, Uruguay, Venezuela, Mexico, Peru, Colombia, giving talks and workshops… the perfect place to learn a lot about Linux, Ubuntu ,Community, all in this amazing event.

 

 

You can find more information about the UbuconLA in the official site and wikipage


Mattia Migliorini: Melany: Menu Item Title Attribute Issue

Planet Ubuntu - Sat, 2014-04-19 17:31

Today, tweaking the Bootstrap_Walker class used by Melany for another project, I discovered an interesting issue with the title attribute.

Melany allows you to prepend a menu item with an icon coming from the Glyphicon set included in Twitter Bootstrap in a very easy way: just put the glyphicon name in the menu item’s title attribute field and let the Melany do the rest. See an example in the following image:

How to prepend icons to menu items

So, what’s the problem? Well, if you try to define a true title attribute, it won’t work, because the Bootstrap_Walker handles this attribute as if it were an icon. Let me do an example. If you want to set the title attribute to “This link opens in a new tab”, the resulting markup is:

<a href="[menu_item_url]"><span class="glyphicon This link opens in a new tab"></span>&nbsp;[navigation_label]</a>

Of course, you wanted something like this:

<a href="[menu_item_url]" title="This link opens in a new tab">[navigation_label]</a>

I solved this issue with a simple check to see if the word glyphicon is in the title attribute, so you can now use this real attribute without problems. The fix is already in the 1.1.0-dev version, but will soon be released in the 1.0.5 series too.

I hope this has not caused you too many hassles.

Oh, do you know Melany 1.1.0 Alpha2 has been released? Check it out!

Ubuntu GNOME: Reading the Release Notes is a must-do step

Planet Ubuntu - Sat, 2014-04-19 12:18

Hi,

Two days ago, the entire world has celebrated the release of Ubuntu GNOME 14.04 LTS and the other official flavours of Ubuntu.

Ubuntu GNOME Team has received many Emails and Posts on our Social Media Channels about the very same question/issue.

“Why the system information is showing Ubuntu 13.10 instead of Ubuntu 14.04″?!

Same question is being asked daily even before the final release of Ubuntu GNOME 14.04.

Ubuntu GNOME Team is asking everyone to please read the release notes of Ubuntu GNOME 14.04 LTS before downloading or upgrading to Ubuntu GNOME 14.04 LTS.

This is actually a must-do step with any new release/version of any Operating System/Software in the world and to be more specific here, it is a must-do step every time Ubuntu and its official flavours announce a new release every 6 months.

Why reading the release notes is very important?
The answer is very simple: because the release notes will explain everything about the new release and above all, show the known issues for every new release that all users must be aware of before anything else.

Sorry for the inconvenience
Ubuntu GNOME Team would like to apologize if we caused any kind of confusion and/or headache to the users of Ubuntu GNOME. Our Developers are working on the known issues, specially this problem:

System Details shows Ubuntu 13.10 instead of 14.04

A Workaround
Meanwhile, you can check and verify which release/version of Ubuntu GNOME you’re using by following these steps:

How can I find the version of Ubuntu that is installed?

Thank you!
As always, thank you for choosing and using Ubuntu GNOME and thanks for reading this very important note. Please keep that in mind with each and every release, you do need to read the release notes. This will save your time and save the trouble for you and for everyone else.

Enjoy and have fun with Ubuntu GNOME 14.04 LTS

Ali/amjjawad
On behalf of Ubuntu GNOME Team

Adnan Quaium: Ubuntu 14.04 Release Party

Planet Ubuntu - Sat, 2014-04-19 09:56
We had the Trusty Tahr Release Party today at the University of Liberal Arts Bangladesh (ULAB), Dhaka. It was the official Ubuntu 12.04 release party of Ubuntu Bangladesh LoCo team in cooperation with “ULAB Computer Programming Club”. This time, we did it within two days of … Continue reading →

Paul Tagliamonte: Hy at PyCon 2014

Planet Ubuntu - Sat, 2014-04-19 00:13

I gave a talk this year at PyCon 2014, about one of my favorite subjects: Hy. Many of my regular readers will have no doubt explored Hy's thriving GitHub org, played with try-hy, or even installed it locally by pip installing it. I was lucky enough to be able to attend PyCon on behalf of Sunlight, with a solid contingint of my colleagues. We put together a writeup on the Sunlight blog if anyone was interested in our favorite talks.

Tons of really amazing questions, and such an amazingly warm reception from so many of my peers throughout this year's PyCon. Thank you so much to everyone that attended the talk. As always, you should Fork Hy on GitHub, follow @hylang on the twitters, and send in any bugs you find!

Hopefully I'll be able to put my talk up in blog-post form soon, but until then feel free to look over the slides or just watch the talk.

An extra shout-out to @akaptur for hacking on Hy during the sprints, and giving the exception system quite the workthrough. Thanks, Allison!

Serge Hallyn: Xspice in containers

Planet Ubuntu - Fri, 2014-04-18 20:12

For some time I’ve been wanting to run ubuntu-desktop and others, remotely, in containers, using spice. Historically vnc has been the best way to do remote desktops, but spice should provide a far better experience. Unfortunately, Xspice has always failed for me, most recently segfaulting on startup. But fortunately, this is fixed in git, and I’m told a new release may be coming soon. While waiting for the new release (0.12.7?), I pushed a package based on git HEAD to ppa:serge-hallyn/virt.

You can create a container to test this with as follows:

lxc-create -t download -n desk1 -- -d ubuntu -r trusty -a amd64 lxc-start -n desk1 -d lxc-attach -n desk1

Then inside that container shell,

add-apt-repository ppa:serge-hallyn/virt apt-get update apt-get install xserver-xspice ubuntu-desktop

ubuntu-desktop can take awhile to install. You can simply install fvwm and xterm if you want a quicker test. Once that’s all one, copy the xspice configuration file into your home directory, uncompress it, set the SpiceDisableTicketing option (or configure a password), and use the config file to configure an Xorg session:

cp /usr/share/doc/xserver-xspice/spiceqxl.xorg.conf.example.gz /root cd /root gunzip spiceqxl.xorg.conf.example.gz cat >> spiceqxl.xorg.conf.example.gz << EOF Option "SpiceDisableTicketing" "1" EOF /usr/bin/Xorg -config /root/spiceqxl.xorg.conf.example :2 &

Now fire up unity, xterm, or fvwm:

DISPLAY=:2 unity

Now connect using either spicy or spicec,

spicec -h -p 5900

Of course if the container is on a remote host, you’ll want to set up some ssh port forwards to enable that, but if needed then that’s a subject for another post.


Sam Hewitt: Microwave-Irradiated Potato Chips

Planet Ubuntu - Fri, 2014-04-18 20:00
A little radiation goes a long way.

Your microwave can be used for more than reheating coffee.

It is far more versatile a device, for instance, you can make these fat-free potato chips ("crisps" for you British gentlepeople) in one with very little effort.

    Ingredients
  • 1 potato,
  • sea salt, to taste
  • any other seasoning or spice that you'd like to flavour the chips with.
  • Needed Equipment
  • Microwave
  • Useful Equipment
  • a mandoline –brilliant thing to have, even a sub-$20 will do
  • a silicon sheet –for a non-stick surface in the microwave, I recommend the brand "Silpat"
    Directions
  1. Thinly cut the potato into even, 2-3 millimeter slices.
  2. Here, a mandoline is incredibly useful (even perhaps ideal or necessary).
  3. Rinse the excess starch off the potato slices and shake/pat/spin off the excess water.
  4. Place the slices onto a non-stick microwave-safe (no metals!) sheet, without overlap.
  5. Microwave on high power for 2 minutes. This'll remove a lot of the water in the potato and you'll begin to see them browning.
  6. Flip the slices and microwave for another minute. Keep an eye on them while they're in there to prevent burning.
  7. Remove any nicely browned chips.
  8. For any not fully done, zap on high in 10 second intervals until they too are browned.
  9. Season with salt, to your tastes, and/or any other thing really.
  10. Enjoy, guilt-free. :)

Ronnie Tucker: PLUMgrid Virtual Network Infrastructure Achieves Certification for Red Hat Enterprise Linux OpenStack Platform

Planet Ubuntu - Fri, 2014-04-18 19:18

PLUMgrid , the leader in Virtual Network Infrastructure (VNI), today announced that PLUMgrid VNI 3.0 has achieved certification for Red Hat Enterprise Linux OpenStack Platform . The certification ensures that PLUMgrid VNI 3.0 has been integrated, tested and certified for use with Red Hat Enterprise Linux OpenStack Platform.
PLUMgrid VNI 3.0 is a secure virtual networking product for large-scale OpenStack clouds. Built using PLUMgrid Platform and IO Visor™ technology , it provides an easy and simple solution to build cloud infrastructure at scale and offer secure, multi-tenant network services to OpenStack cloud users. Based on a highly automated workflow, PLUMgrid VNI 3.0 enables applications and users to deploy private Virtual Domains™ in seconds without changing the physical network fabric.

Source:

http://www.marketwatch.com/story/plumgrid-virtual-network-infrastructure-achieves-certification-for-red-hat-enterprise-linux-openstack-platform-2014-04-14

Ronnie Tucker: IBM: Now Is The Time For KVM

Planet Ubuntu - Fri, 2014-04-18 19:17

IBM says that now is great time for KVM (Kernel-based Virtual Machine) technology as a result of key contributions from its large developer community.
The KVM hypervisor is an open source virtualization technology and, increasingly, it is becoming an important tool in any Linux user’s handbook, especially in light of OpenStack.
KVM is a full virtualization solution for Linux on x86 hardware containing virtualization extensions (Intel VT or AMD-V) and consisting of a loadable kernel module (kvm.ko) that provides the core virtualization infrastructure and a processor-specific module (kvm-intel.ko) or (kvm-amd.ko).
IBM says that hypervisors have had to better manage compute, network, and storage resources — and that this need that has been fulfilled by KVM.

Source:

http://www.drdobbs.com/open-source/ibm-now-is-the-time-for-kvm/240167057

Dustin Kirkland: Docker in Ubuntu, Ubuntu in Docker

Planet Ubuntu - Fri, 2014-04-18 19:11




This article is cross-posted on Docker's blog as well.
There is a design pattern, occasionally found in nature, when some of the most elegant and impressive solutions often seem so intuitive, in retrospect.


For me, Docker is just that sort of game changing, hyper-innovative technology, that, at its core,  somehow seems straightforward, beautiful, and obvious.



Linux containers, repositories of popular base images, snapshots using modern copy-on-write filesystem features.  Brilliant, yet so simple.  Docker.io for the win!


I clearly recall nine long months ago, intrigued by a fervor of HackerNews excitement pulsing around a nascent Docker technology.  I followed a set of instructions on a very well designed and tastefully manicured web page, in order to launch my first Docker container.  Something like: start with Ubuntu 13.04, downgrade the kernel, reboot, add an out-of-band package repository, install an oddly named package, import some images, perhaps debug or ignore some errors, and then launch.  In few moments, I could clearly see the beginnings of a brave new world of lightning fast, cleanly managed, incrementally saved, highly dense, operating system containers.

Ubuntu inside of Ubuntu, Inception style.  So.  Much.  Potential.


Fast forward to today -- April 18, 2014 -- and the combination of Docker and Ubuntu 14.04 LTS has raised the bar, introducing a new echelon of usability and convenience, and coupled with the trust and track record of enterprise grade Long Term Support from Canonical and the Ubuntu community.
Big thanks, by the way, to Paul Tagliamonte, upstream Debian packager of Docker.io, as well as all of the early testers and users of Docker during the Ubuntu development cycle.Docker is now officially in Ubuntu.  That makes Ubuntu 14.04 LTS the first enterprise grade Linux distribution to ship with Docker natively packaged, continuously tested, and instantly installable.  Millions of Ubuntu servers are now never more than three commands away from launching or managing Linux container sandboxes, thanks to Docker.


sudo apt-get install docker.io
sudo docker.io pull ubuntu
sudo docker.io run -i -t ubuntu /bin/bash


And after that last command, Ubuntu is now officially running within Docker, inside of a Linux container.

Brilliant.

Simple.

Elegant.

User friendly.

Just the way we like things in Ubuntu, thanks to our friends at Docker.io!

Cheers,:-Dustin

Ted Gould: HUD for the command line

Planet Ubuntu - Fri, 2014-04-18 17:46

Most expert users know how powerful the command line is on their Ubuntu system, but one of the common criticisms of it is that the commands themselves are hard to discover and remember the exact syntax for. To help a little bit with this I've created a small patch to the Ubuntu Terminal which adds entries into the HUD so that they can be searched by how people might think of the feature. Hopefully this will provide a way to introduce people to the command line, and provide experienced users with some commands that they might have not known about on their Ubuntu Phone. Let's look at one of the commands I added:

UnityActions.Action { text: i18n.tr("Networking Status") keywords: i18n.tr("Wireless;Ethernet;Access Points") onTriggered: ksession.sendText("\x03\nnm-tool\n") }

This command quite simply prints out the status of the networking on the device. But some folks probably don't think of it as networking, they just want to search for the wireless status. By using the HUD keywords feature we're able to add a list of other possible search strings for the command. Now someone can type wireless status into the HUD and figure out the command that they need. This is a powerful way to discover new functionality. Plus (and this is really important) these can all be translated into their local language.

It is tradition in my family to spend this weekend looking for brightly colored eggs that have been hidden. If you update your terminal application I hope you'll be able to enjoy the same tradition this weekend.

Stephan Adig: Thanks for Ubuntu 14.04 LTS

Planet Ubuntu - Fri, 2014-04-18 15:13

So at last it’s here. Ubuntu 14.04 LTS

And I have to say ‘Thank you’ for pushing this out.

I am running Trusty Tahr for a long time now, while it was still in development on my workstation. And it’s one of the best releases so far.

Even during development only some glitches were encountered, but were easily workarounded, and this is actually pretty amazing.

When you followed Ubuntu for some years now (and to some extend also invovled in pushing software to it), you know that this wasn’t always the case.

We had a couple of really serious hickups, but this release was very handsome. I think Canonicals push towards automated QA and the upload pocket behaviour change were the right things to do.

Thanks Guys, for delivering this amazing release. You really can celebrate and drink a lot of booze and have a good meal (well, now that Jono is the definitive Ubuntu Smoker King, he could serve some delicious pulled pork or whatever he is able to smoke ;))

Again, thank you, you all know who you are. You guys are amazing. Rock On!

Pages

Subscribe to Free Software Magazine aggregator