FLOSS Project Planets

Russ Allbery: Catch-up haul

Planet Debian - Sun, 2015-05-24 19:44

As always, even though I've not been posting much, I'm still buying books. This is a catch-up post listing a variety of random purchases.

Katherine Addison — The Goblin Emperor (sff)
Milton Davis — From Here to Timbuktu (sff)
Mark Forster — How to Make Your Dreams Come True (non-fiction)
Angela Highland — Valor of the Healer (sff)
Marko Kloos — Terms of Enlistment (sff)
Angela Korra'ti — Faerie Blood (sff)
Cixin Liu — The Three-Body Problem (sff)
Emily St. John Mandel — Station Eleven (sff)
Sydney Padua — The Thrilling Adventures of Lovelace and Babbage (graphic novel)
Melissa Scott & Jo Graham — The Order of the Air Omnibus (sff)
Andy Weir — The Martian (sff)

Huh, for some reason I thought I'd bought more than that.

I picked up the rest of the Hugo nominees that aren't part of a slate, and as it happens have already read all the non-slate nominees at the time of this writing (although I'm horribly behind on reviews). I also picked up the first book of Marko Kloos's series, since he did the right thing and withdrew from the Hugos once it became clear what nonsense was going on this year.

The rest is a pretty random variety of on-line recommendations, books by people who made sense on the Internet, and books by authors I like.

Categories: FLOSS Project Planets

Norbert Preining: TeX Live 2015 DVD preparation starts

Planet Debian - Sun, 2015-05-24 18:50

As the last step in the preparation of the TeX Live 2015 release we have now completely frozen updates to the repository and built the (hopefully) final image. The following weeks will see more testing and preparation of the gold master for DVD preparation.

The last weeks were full of frantic rebuilds of binaries, in particular due to the always in the last minute found bugs in several engines. Also already after the closing time we found a serious problem with Windows installations in administrator mode, where unprivileged users didn’t have read access to the format dumps. This was due to the File::Temp usage on Windows which sets too restrictive ACLs.

Unless really serious bugs show up, further changes will have to wait till after the release. Let’s hope for some peaceful two weeks.

So, it is time to prepare for release parties

Categories: FLOSS Project Planets

Robin Wilson: How to: Log electricity usage from a CurrentCost EnviR – Part 1

Planet Python - Sun, 2015-05-24 16:48

After borrowing a CurrentCost electricity usage meter from my local library (if you’re in the area, then Eastleigh library will loan you one for free!), I decided to buy one, as I’d found it very useful in trying to reduce my electricity usage. The benefit of buying one as opposed to borrowing one was that I could start connecting it to a computer and logging data (the one I borrowed didn’t come with a connection cable).

So, I bought a CurrentCost EnviR meter on eBay for around £15:

I was impressed with how easy it was to get data from it to the computer. All I did was:

  1. Plug it in to a USB port on my Linux server with the cable (which was provided, but can also be bought separately if necessary – or even made yourself)
  • Check what serial device the USB-to-serial adaptor (which is built-in to the cable) is coming up as by running dmesg and checking the final lines of the output. A similar command should work on OS X, and on Windows you should be able to check Device Manager and see what COM port number it has been assigned. In my case, it was /dev/ttyUSB0.

  • Test it using a serial communication program. For example, on Linux I ran sudo minicom -D /dev/ttyUSB0 -b 57600 (the last argument is essential as it sets the baud rate correctly for the device). On Windows something like Hyperterminal could be used.

  • You should find that you get a nice XML string back – something like this:

    <msg><src>CC128-v1.48</src><dsb>00008</dsb> <time>21:36:48</time><tmpr>23.8</tmpr> <sensor>0</sensor><id>00077</id><type>1</type> <ch1><watts>00419</watts></ch1></msg>

    That’s fairly self-explanatory, but just for reference:

    • src: the model number of the CurrentCost
    • dsb: days since birth (how long since you turned on the CurrentCost and it started collecting data)
    • time: self-explanatory
    • tmpr: temperature (degrees C)
    • ch1: you can have multiple sensors attached to the CurrentCost, so this tells you which one it is
    • watts: current power usage in Watts

    I’ve written the Python code below to read the XML over the serial connection, parse the data and return it. You’ll need to install pyserial and untangle (a handy XML parsing library for simple, small bits of XML) first using pip.

     """""" <!DOCTYPE html> <html> <head> <meta http-equiv="Content-type" content="text/html; charset=utf-8"> <title>Server Error &middot; Gist</title> <style type="text/css" media="screen"> body { background: #f1f1f1; font-family: "HelveticaNeue-Light", Helvetica, Arial, sans-serif; text-rendering: optimizeLegibility; -webkit-font-smoothing: antialiased; } .container { margin: 100px auto; width: 600px; text-align: center; } a { color: #4183c4; text-decoration: none; } a:visited { color: #4183c4 } a:hover { text-decoration: none; } h1 { letter-spacing: -1px; line-height: 60px; font-size: 60px; font-weight: 100; margin: 0px; text-shadow: 0 1px 0 #fff; } p { color: rgba(0, 0, 0, 0.5); margin: 20px 0 40px; } ul { border-top: 1px solid #ccc; list-style: none; margin: 20px 0; padding: 20px 0; } li { display: table-cell; font-weight: bold; width: 1%; } </style> </head> <body> <div class="container"> <h1>OH NOES, 404.</h1> <p>We seem to have missed the <em>gist</em> of that <em>gist</em> you were looking for.</p> <ul id="error-suggestions"> <li><a href="https://github.com/contact">Contact Support</a></li> <li><a href="https://status.github.com">Status Site</a></li> <li><a href="https://twitter.com/github">@github</a></li> </ul> <p><img src="https://github.s3.amazonaws.com/media/maint-logo.png" alt="GitHub"></p> </div> </body> </html>

    In the next part of this series, I’ll show how I linked this data up to Graphite to make lovely plots. As a quick taster, here is my current ‘dashboard’ (click for a larger view):

    Categories: FLOSS Project Planets

    Wouter Verhelst: Fixing CVE-2015-0847 in Debian

    Planet Debian - Sun, 2015-05-24 15:18

    Because of CVE-2015-0847 and CVE-2013-7441, two security issues in nbd-server, I've had to updates for nbd, for which there are various supported versions: upstream, unstable, stable, oldstable, oldoldstable, and oldoldstable-backports. I've just finished uploading security fixes for the various supported versions of nbd-server in Debian. There're various relevant archives, and unfortunately it looks like they all have their own way of doing things regarding security:

    • For squeeze-lts (oldoldstable), you check out the secure-testing repository, run a script from that repository that generates a DLA number and email template, commit the result, and send a signed mail (whatever format) to the relevant mailinglist. Uploads go to ftp-master with squeeze-lts as target distribution.
    • For backports, you send a mail to the team alias requesting a BSA number, do the upload, and write the mail (based on a template that you need to modify yourself), which you then send (inline signed) to the relevant mailinglist. Uploads go to ftp-master with $dist-backports as target distribution, but you need to be in a particular ACL to be allowed to do so. However, due to backports policy, packages should never be in backports before they are in the distribution from which they are derived -- so I refrained from uploading to backports until the regular security update had been done. Not sure whether that's strictly required, but I didn't think it would do harm; even so, that did mean the procedure for backports was even more involved.
    • For the distributions supported by the security team (stable and oldstable, currently), you prepare the upload yourself, ask permission from the security team (by sending a debdiff), do the upload, and then ask the security team to send out the email. Uploads go to security-master, which implies that you may have to use dpkg-buildpackage's -sa parameter in order to make sure that the orig.tar.gz is actually in the security archive.
    • For unstable and upstream, you Just Upload(TM), because it's no different from a regular release.

    While I understand how the differences between the various approaches have come to exist, I'm not sure I understand why they are necessary. Clearly, there's some room for improvement here.

    As anyone who reads the above may see, doing an upload for squeeze-lts is in fact the easiest of the three "stable" approaches, since no intermediate steps are required. While I'm not about to advocate dropping all procedures everywhere, a streamlining of them might be appropriate.

    Categories: FLOSS Project Planets

    A neat UNIX trick for your bash profile

    Planet KDE - Sun, 2015-05-24 11:12

    Hi folks! I have been spending a lot of time with KStars lately. I will write a detailed account on the work done till now, but here’s something I found interesting. This, I think is a handy ‘precautionary’ trick that every newbie should implement to avoid pushing to the wrong git repo/branch.

    Here’s what you do. Open up the konsole and type cd ~ (This should take you to your home directory. Now what we need to do is add one line to your .bashrc file.

    $nano .bashrc

    Opens up your .bashrc file in the nano editor (you could choose vim, or emacs too).

    Add this line export PS1=’\W$(__git_ps1 “(%s)”)> to the part of the ‘if block’ that pertains to bash completion. In my case this is how my .bashrc looks.

      if [ -f /usr/share/bash-completion/bash_completion ]; then
        . /usr/share/bash-completion/bash_completion
            export PS1=’\W$(__git_ps1 “(%s)”)> ‘
      elif [ -f /etc/bash_completion ]; then
        . /etc/bash_completion

    What this does is that it changes the text on your konsole. Whenever you enter a git repository, the text on your console reads the repo name with the git branch you are on currently (hence the %s to the __git_ps1 variable). This is how my kstars repository now looks.

    ~> cd Projects/kstars/
    kstars(gsoc2015-constellationart)> git branch
    * gsoc2015-constellationart
    kstars(gsoc2015-constellationart)> git checkout master
    Switched to branch ‘master’
    Your branch is up-to-date with ‘origin/master’.

    Now you can always know what branch you are on, without typing git branch. Pretty neat!



    Categories: FLOSS Project Planets

    CiviCRM Blog: Easier creation of email newsletters - New version

    Planet Drupal - Sun, 2015-05-24 10:24

    When preparing an email newsletter, one part of it that is time consuming is gathering together all the content that is needed. In my experience, virtually all the content already exists elsewhere, such as in the local CMS, in CiviCRM, or on a blog, or some other online source.    So I was thinking how can I make this process easier.  What I did: I created mail merge tokens for CiviCRM that autofill a list of recent blog posts, stories, or any other type of CMS content.  So the end-user sees a list of tokens, one for each content type, each term/category, each aggregator feed,  and for each date range. Such as "Content of type 'blog' created in the last 7 days" .  What is particulary powerful about this approach, is that if you are also using a CMS aggregator (such as the aggregator module in Drupal core) then virually any external RSS feed is turned into CMS content, which is now available as a CiviCRM token. (The original blog post about this extension is at: https://civicrm.org/blogs/pogstonesarahgladstone/easier-creation-email-newsletters-content-tokens )

    Thanks to community involvement (specifically thanks to https://github.com/jorich-2000), there is a new version of the Content Token extension.  This version now supports Joomla, in addition to Drupal7, Drupal6, and WordPress.

    The lastest version is 2.9 and can be downloaded from: https://civicrm.org/extensions/content-tokens

    I am looking forward to getting feedback on this.




    Categories: FLOSS Project Planets

    Doing Math with Python: Introduction to "Doing Math with Python"

    Planet Python - Sun, 2015-05-24 09:27

    Hi all, this is the blog for my book "Doing Math with Python".

    The first six chapters of the book are already available via the publisher's early access program. You can learn briefly about each chapter on the About page. Going forward, I will be sharing updates regarding the book and posting original content related to that discussed in the book.

    You can stay connected with the book, its readers and me via the following channels:

    Categories: FLOSS Project Planets

    Hyunsik Choi: 글쓰기 자동 공유 해제

    Planet Apache - Sun, 2015-05-24 05:23

    가만 보니 워드프레스에 글을 쓰다말아 Draft로 표시된 글만 50여개이다. 초반에 글을 잘 쓰다가 다듬는 중에 나 스스로도 만족 못해서 완성을 못한 글들이 50여개 인데… 내 성격을 보여주는 단면인 것 같아서 씁쓸하기도 하다. 글 쓰긴 뿐만 아니라 다른 것들에서도 눈만 높은데 반해 내 실력이 막상 따라주지 못해 만족하지 못해 내놓지 못한 일들이 많다. 사실 Tajo 같은 경우도 어쩌다 보니 공유해달라는 요청을 받아 공유했다가 여기까지 오게된 케이스 인데 그 당시에도 부끄러움에 공유를 망설였던 기억이 있다.

    그런데 글을 꾸준히 쓰고 싶은 의욕은 항상 있어왔다. 혼자 정리한 내용도 꽤 많고 지금도 꾸준히 뭔가를 배우거나 개발을 하는 중이라 공유하고 싶은 것도 많다. 순간순간 느끼는 교훈이나 배운 것들은 나중에 내가 다시 보기 위해 기록하고 싶다. 일단은 그 부담을 줄여보고자 기본적으로 트위터나 페이스북을 통해 공유되는 기능을 꺼보았다. 아무래도 SNS를 통해 지인들에게 공유되는 것 보다는 필요에 따라 검색으로 들어오는 분들만 본다면 부담이 덜할 것 같다는 생각이다.

    그럼에도 불구하고 잘 모르겠다. 꾸준히 기록해 나갈 수 있을지는.. 한번 노력해볼란다.

    Categories: FLOSS Project Planets

    Postgresql Native JSON Support – Best of Both SQL & NoSQL Worlds

    LinuxPlanet - Sun, 2015-05-24 04:29

    Postgfresql joined the NoSQL movement way back in September 2012 with the release of Postgresql 9.2 which  introduced native JSON support via the JSON data type  .  Unlike the new kids on the block, rebel-without-a-cause, NoSQL data stores Postgresql hasn't rejected its rich and robust relational database heritage but instead assimilated the technological diversity of the NoSQL world and added them its own technological advantage, like any enterprise technology juggernaut would. Sorry Juan Luc!

    Postgresql Training
    For Administrators and Developers Postgresl Native JSON Support - NoSQL with the Benefits of SQL!

    What Postgresql 9.1 began, 9.2 continued with the introduction of a rich set of functions to enable translation between the JSON and relational world. In Postgresql 9.3 the JSONB data type was introduced which allows for the creation of indexes and partial indexes on JSONB data types, that is down to a property level, on a JSON object.

    Postgres - Write Functions (Stored Procedures) in JavaScript

    Along with Postgresql's release of native JSON support in 2012 came an extension that integrated the Google V8 JavaScript engine as a supported language into Postgres, allowing developers to write functions,aka stored procedures (but so much more!), in JavaScript. The extension provides several functions that allow execution of SQL statements directly from JavaScript. 

    Enabling Postgresql JavaScript Support

    To enable postgres functions written in JavaScript you will need to install and then enable the plv8 extension. On Ubuntu Linux you can install the extension with: (You may need to change the version of Postgresql 9.4 is for 15.04)

    "sudo apt-get install postgresql-9.4-plv8"

    You will also have to enable the extension in  postgres to enable JavaScript language support. You can do this in the psql command line client after connecting to your database with:

    "create extension plv8;"

    Postgresql JSON/REST Example

    Let say we have a form that is to capture profile details. It will request, via a rest api, a json array of provinces and related cities to populate a linked drop down list dynamically.  Beside the province and city the form will also capture first name, last name and a tag list of technologies the person is interested in. The application designers want the form to be flexible and new fields should be able to be added over time without having to recode the database back-end.

    Creating the Postgresql Function to Return JSON Array of Provinces and Related Cities

    To achieve the first goal, of responding with an array of JSON objects to populate the drop downs, we will create a few tables making use of other unique features of Postgresql. If you going to be using the JSON data type, or any other NoSQL database for that matter, you will already have given up on loose coupling at the data store level so we might as well take advantage of all Postgres has to offer. Besides it makes life a lot easier.

    First we will create an enumeration of our provinces with:

    "create type province as enum ('Eastern Cape','Free State','Gauteng','KwaZulu Natal','Limpopo','Mpumalanga','North West','Northern Cape','Western Cape');"

    A postgres enum can be appended and changed later with an "alter type province add .." should we so desire. Next we will create the list of cities that belong in each province to enable the HTML 5 front-end to filter the lookup list after the selection of the province.

    For this we will use Postgresql's array feature, which allows us to store an array of data types in a database column.

    'create table province_city (id serial primary key, "province" province, cities text[]);'

    Now we can populate our province_city table as follows: (Later we can add cities as needed by appending to the array)

    insert into province_city (province,cities) values ('Western Cape',array['Cape Town','Franshoek','Hermanus','Stellenbosch']),  ('Gauteng',array['Alexandra','Johannesburg','Midrand','Soweto']), ('KwaZulu Natal',array['Durban','KwaMashu','Pietermaritzburg','Umhlanga Rocks']);

    At this point we have all we need to create our function to return the JSON array of  provinces and related cities. The function is defined below using JavaScript:

    create or replace function getProvinceCities()  returns JSON as
        var json_result = plv8.execute('SELECT province,cities FROM province_city');
        return JSON.stringify(json_result);
    LANGUAGE plv8;

    So how will this function be called from the web server? Below is an example, in PHP, to call the function from the web tier, usually we would pass the JSON to the response object but we process it in PHP here for demonstration pruposes. You can run this without a web server by typing "php <name-of-php-script>", after adjusting for your setup.

                    $conn = new PDO('pgsql:host=localhost;port=5432;dbname=demo','postgres','postgres');
                    $conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
                    $prep = $conn->prepare('select getProvinceCity()');
                    $json =  $prep->fetchColumn(0);
                    $obj = json_decode($json,true);
            } catch(PDOException $e){

    So we have completed our first task of providing the data to the Web2.0 front end in JSON format via rest calls.

    Saving JSON Objects to Postgres

    So the user is presented with a form, she fills out the necessary, selects the province and the filtered city and posts the results back to the web server via an rest post method call. We don't want to dissect the response and then save the individual properties into columns in a table because the user profile section keep changing with fields being added and taken away on a regular basis. The only fields that are more-or-less stable are the core fields of Province, City, First Name and Last Name.

    To accommodate this requirement we will store the JSON response as is, in the Postgres table using the JSONB data type which will allow us to index and query the data.

    "create table people (id serial primary key,person jsonb);"

    We can now create our function to populate this table. We could populate the table directly via a sql statement but we want to perform some validation to ensure we have a valid province and city first. Below is the script to create our insertPerson function which will insert a person JSON object into our Postgresql table after validation, throwing an error if there is a violation.

    create or replace function insertPerson(person json) returns void as
            var provinces = plv8.execute('select enum_range('Western'::province,null::province)');
            if (provinces[0].enum_range.indexOf(person.province)!=-1){
                    var cities = plv8.execute('select cities from province_city where province =$1',person.province);
                    if (cities[0].cities.indexOf(person.city)!=-1){
                            plv8.execute('insert into people (person) values($1)',JSON.stringify(person));
                            throw "Invalid city";
                    throw "Invalid Province";
    language plv8;

    If the object passed validation we persist the JSON object to the people table. We can test our function from the psql cli client with:

    select insertPerson('{"firstname":"Bob", "lastname":"Marley","province":"Gauteng","city":"Johannesburg", "tech":["Java","PHP","Linux","Postgres"]}');

    How do we call this function from the web tier? Here again we have a PHP script which receives the posted JSON data and persists it to the database. This script creates the JSON object for demo purposes in PHP. It shows what happens when an valid json object is presented, what happens when an  invalid province is received and how the JSON type can change between calls without requiring a schema change on the database side.

                    //create a test json object. This should be retrieved from the post.                
                    $json = json_encode($person);
                    //send the json object to postgres for validation and persistence
                    $conn = new PDO('pgsql:host=localhost;port=5432;dbname=demo','postgres','postgres');
                    $conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
                    $prep = $conn->prepare('select insertPerson(:json)');
                    $prep->bindParam(':json',    $json);
                    echo "SUCCESSFULLY INSERTED RECORD".PHP_EOL;
           } catch(PDOException $e){
                    echo "VALIDATION ERROR".PHP_EOL;
                    echo $e->getMessage().PHP_EOL;        

           try {
                    //create a invalid json object.
                    //should throw an exception               
                    $json = json_encode($person);
                    $prep = $conn->prepare('select insertPerson(:json)');
                    $prep->bindParam(':json',    $json);
            } catch(PDOException $e){
                    echo "VALIDATION ERROR".PHP_EOL;
                    echo $e->getMessage().PHP_EOL;        

                    //create a json object with extended attributes. This should be retrieved from the post.                
                    $json = json_encode($person);
                    //send the json object to postgres for validation and persistence
                    $conn = new PDO('pgsql:host=localhost;port=5432;dbname=demo','postgres','postgres');
                    $conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
                    $prep = $conn->prepare('select insertPerson(:json)');
                    $prep->bindParam(':json',    $json);
                    echo "SUCCESSFULLY INSERTED RECORD".PHP_EOL;
           } catch(PDOException $e){
                    echo "VALIDATION ERROR".PHP_EOL;
                    echo $e->getMessage().PHP_EOL;        

    Postgresql Not Your Every Day Enterprise Database

    I hope this article showed what is possible with Postgresql. The example is a bit contrived by demonstrates what is possible when a great relational database engine is combined with NoSQL principles. We haven't even looked at querying the JSON data - I will deal with that in a future post.

    Categories: FLOSS Project Planets

    Twisted Matrix Labs: Twisted 15.2.1 Released

    Planet Python - Sun, 2015-05-24 01:22
    On behalf of Twisted Matrix Laboratories, I am honoured to announce the release of Twisted 15.2.1.

    This is a bugfix release for the 15.2 series that fixes a regression in the new logging framework.

    You can find the downloads on PyPI (or alternatively on the Twisted Matrix Labs website).

    Many thanks to everyone who had a part in this release - the supporters of the Twisted Software Foundation, the developers who contributed code as well as documentation, and all the people building great things with Twisted!

    Twisted Regards,
    Categories: FLOSS Project Planets

    Reminder: Evolving KDE survey milestone on May 31st

    Planet KDE - Sun, 2015-05-24 00:44

    Evolution is a powerful concept and tool. When harnessed properly, humans have been able to tailor and adapt crops and domesticate animals. We’ve been able to grow the Dutch unnecessarily tall and create beautiful and consequence-free theme parks as shown in the Jurassic Park documentary series on the BBC. However, when not monitored closely or left to nature’s own devices, the result is the terrifying land based sharks that have caused such recent devastation across most of Australia.

    It has already been a month since KDE launched Evolving KDE: an initiative that allows our healthy community to continue growing organically while setting goals, direction, and taking action. The digital world is only accelerating in its pace of change; will we be proactive or reactive?


    It has also been eight long years since I created this image for KDE, and I firmly believe the concept to be more relevant than ever. KDE is powerful enough to respect the different backgrounds, geographies and goals of the individual while channeling that diversity as a strength.  With unity and vision, our best is yet to come.

    The beauty of the Evolving KDE announcement to me came from the three distinctive voices I’ve seen post on the topic here on the Planet.

    You have Lydia, who as President of the KDE e.V. shows leadership  in announcing  and defining this initiative.

    You have Paul, universally known as being to smart for his own good and apparently having enough time to read more that xkcd comics, showing the theory, necessity and impact of such ventures.

    And finally you have Boudewijn, who actually gives a testimonial on his own experiences with Krita and powerful results yielded from taking the time to chart a course and create a plan to reach that destination.  Years ago, I distinctly remember Krita’s identity crisis, lack of momentum, and the very purposeful and honest conversations on their current state, definition of goals, and the plans created to achieve them.  When he writes, “Krita’s evolution has gone from being a weaker, but free-as-in-freedom alternative to a proprietary application to an application that aspires to be the tool of choice, even for people who don’t give a fig about free software” he may be underselling the hard work, the vision, the plan, and the metamorphosis.

    So, as Lydia shared in her blog post, Evolving KDE is an ongoing journey, but it does have a specific train stop coming up quickly.  On May 31st, we’ll be taking the survey results entered.  We’ll summarize, review, discuss and present at Akademy.  The survey will remain open, and the questions will likely evolve over time (it be hypocritical to remain static when asking about change, n’est-ce pas?), but May 31st is a milestone necessary to harvest and present.

    With one week remaining, you have plenty of time, so take the short and simple Evolving KDE Survey, and have your voice heard!


    Categories: FLOSS Project Planets

    Bryan Pendleton: Stephen Curry is playing at an astonishing level

    Planet Apache - Sat, 2015-05-23 23:18

    I was never a good basketball player, but I love to watch the game; I think it is the best televised sport.

    And Stephen Curry is playing at a simply astonishing level.

    The last time I saw a player playing at this level, it was 1991, and his name was Michael Jordan.

    They're very different players, but Curry is really doing something remarkable.

    Oh, and by the way: Curry's current coach, the one who seems to have figured out how to elevate Curry's play that final little bit until he's truly above and beyond anyone else around him on the court?

    None other than Steve Kerr, who was Jordan's teammate during the great "3-peat" years of 1995-1997.

    Astonishing talent, coupled with a superb coach: total joy to behold.

    This is why sports, when it finds that magical something, is the most fascinating entertainment.

    Categories: FLOSS Project Planets

    PythonClub - A Brazilian collaborative blog about Python: Criação de aplicações no Google App Engine com o Tekton

    Planet Python - Sat, 2015-05-23 23:00
    Google App Engine (GAE)

    É a plataforma de Cloud Computing do Google, com ela você pode desenvolver e hospedar aplicações usando Python (2.7) que escalam facilmente, pagando muito pouco por isso.

    As desvantagens (em relação a outras plataformas de nuvem, como o Heroku por exemplo) são: - Você terá que desenvolver pensando na plataforma (banco de dados NoSQL, por isso o Django não é recomendável.). - Versão do Python é antiga e não há planos para mudar isso no momento.


    É um framework para desenvolvimento Web especialmente pensado para uso no Google App Engine. Nele podemos aproveitar o melhor do Django (scaffold, código HTML e validação de formulários a partir de modelos, apps isoladas) sem perder as vantagens que o GAE nos oferece.

    ## Como iniciar O primeiro passo é baixar o SDK do Google App Engine, com isso pronto podemos começar a conhecer o Tekton:

    $ wget https://github.com/renzon/tekton/archive/master.zip $ unzip master $ mv master projeto_appengine && cd projeto_appengine

    Nesse ponto podemos explorar e conhecer a estrutura de diretórios.

    └── backend ├── appengine ├── apps ├── build_scripts ├── test └── venv $ cd backend/venv/ && ./venv.sh $ source ./bin/activate

    Com o ambiente virtual pronto, tudo deve estar funcionando. Para testar, vamos utilizar o próprio servidor que vem com o pacote antes de subir parao GAE.

    cd ../appengine && dev_appserver.py .

    Tudo certo! Você deve estar vendo o projeto template no seu localhost:8080

    Para realizar o deploy no App Engine:

    appcfg.py update . --oauth2

    Você pode conhecer mais sobre o projeto no Github, no grupo de discussões ou nas vídeo aulas gratuitas no Youtube.

    Categories: FLOSS Project Planets

    Russ Allbery: git-pbuilder 1.34

    Planet Debian - Sat, 2015-05-23 20:59

    Long time without a blog post. My time got eaten by work and travel and work-related travel. Hopefully more content soon.

    This is just a quick note about the release of version 1.34 of the git-pbuilder script (which at some point really should just be rewritten in Python and incorporated entirely into the git-buildpackage package). Guido Günther added support for creating chroots for LTS distributions.

    You can get the latest version from my scripts page.

    Categories: FLOSS Project Planets

    Christian Grobmeier: CloudFront with SSL from S3

    Planet Apache - Sat, 2015-05-23 18:00

    Recently I updated "Time & Bill" and messed it up. It was exhausting two days, but looking back, I learned a lot.

    Categories: FLOSS Project Planets

    Graham Dumpleton: Monitoring the response content from a WSGI application.

    Planet Python - Sat, 2015-05-23 17:44
    I have been focusing in the last couple of posts about the overheads of generating response content from a WSGI application as many separate blocks rather than as one large block. This has illustrated how there can be quite marked differences between different WSGI servers and even with a specific WSGI server depending on how it is configured or integrated into an overall architecture.  In this
    Categories: FLOSS Project Planets

    Python Insider: Python 2.7.10 released

    Planet Python - Sat, 2015-05-23 15:43
    Python 2.7.10 is now available for download.
    Categories: FLOSS Project Planets

    Dan Stromberg: Fibonacci Heap implementation in Pure Python

    Planet Python - Sat, 2015-05-23 13:01

    I've put a Pure Python Fibonacci Heap (priority queue) implementation at:

    1. https://pypi.python.org/pypi/fibonacci-heap-mod
    2. http://stromberg.dnsalias.org/~strombrg/fibonacci-heap-mod/
    It passes pylint and pep8, is thoroughly unit tested, and runs on CPython 2.[67], CPython 3.[01234], Pypy 2.3.1, Pypy3 2.3.1 and Jython 2.7b3.
    It's similar to the standard library's heapq module.  The main difference is Fibonacci heaps have better big-O for some operations, and also support decrease-key without having to remote and re-add.
    This Fibonacci heap implementation is also better abstracted than heapq.
    Categories: FLOSS Project Planets

    Jim Birch: Drupal 7 Panels: Page Manager Existing Pages

    Planet Drupal - Sat, 2015-05-23 11:47

    I plan on doing a more in depth article on how I've been using Panels instead of templates or contexts for laying out this Drupal 7 site, but I feel like I still have more to learn.  Until then, I wanted to share what I found to be a missing piece of the puzzle, Page Manager Existing Pages.

    PMEP allows you to override any page that is in the admin menu for use in Page Manager.  That way, you can create variants, and add whatever layout, content, selection rules, that you want.  Without this plugin, you get an error message in Page Manager when trying to overwrite an existing URL.

    So, where would I use this?  Page Manager comes with defaults for Node, Taxonomy, and some User pages, most of what you need to present your site to the world.  But there are certain administration pages, when viewed in a front end theme that slipped through the cracks.  For example, node/add, which lists all the content types you can add, or the Style Guide Module generated /admin/appearance/styleguide

    Install and configure Page Manager Existing Pages

    Read more

    Categories: FLOSS Project Planets
    Syndicate content