FLOSS Project Planets

Europython: Upcoming EuroPython sprints and barcamp

Planet Python - Fri, 2014-07-25 02:10

Over the weekend there will be a Python BarCamp and of course sprints.

All EuroPython attendees can attend sprints and BarCamp but please register yourself for logistic reasons (registration links on the pages above).

Both events are also free for non-attendees. So if you have friends, co-workers or other people that are interested in Python, please bring them for with you - for free. We only require that they should register at the EuroPython info desk inside the foyer of the bcc.

The sprint orientation and introduction is today, Friday at 2pm in C01.

Join and get some more detailed information about the different sprints and topics.

Categories: FLOSS Project Planets

[Video] [HowTo] CentOS / RHEL 7 Installation with GUI / Custom Partition

LinuxPlanet - Fri, 2014-07-25 00:00
Hello, Today I have tried to Install CentOS 7 on my Virtual Machine. Sharing video of CentOS 7 Installation with GUI and Custom Partition with LVM. Hope this video will help to those who wants to Install and Looking for easy guide for CentOS 7 Installation. CentOS / RHEL 7 Installation Video   Enjoy CentOS […]
Categories: FLOSS Project Planets

NEWMEDIA: DrupalCamp Colorado 2014: Large Scale Drupal

Planet Drupal - Thu, 2014-07-24 23:26
DrupalCamp Colorado 2014: Large Scale DrupalWith less than a week until the camp, here is a preview of what to expect from our team!

Everyone here at NEWMEDIA is extremely enthusiastic about this year's DrupalCamp Colorado, which will be held on August 1st-3rd in Denver. This year’s theme for the camp is “Large Scale Drupal” where the focus is on how  larger organizations can become more collaborative with the Drupal community by pooling ideas and resources together to solve common issues they are facing. There will be a wide variety sessions this year, six of which will be presented by members of NEWMEDIA. We are also very excited about being a Platinum sponsor.

Drupal 8 Module Development: Just the Basics

Start off this years DrupalCamp Colorado right and jump into Drupal 8 module development.  Brandon Williams  will cover the basics of Symphony and the Drupal 8 module , including a review of what has replaced some of the most common hooks from D7. Brandon is an advocate for learning and change and in the technological world we experience that invariably. While Drupal 7 will be the best option for the short-term, it is never too early to dive in to D8 as he describes in why I love D8!

Jenkins 101: A Drupal Perspective

Want to know more about Jenkins from a Drupal perspective and have a better understanding on how Jenkins can be applied to multiple processes? Then you should join Brandon in his second session that will introduce Jenkins from a Drupal perspective and how it has been proven to be beneficial within NEWMEDIA. As a community we can take this knowledge and continue the conversation to help emerge the tools to permit everyone to become more effective.

Securing customers credit card data

Security for your clients credit cards is now a necessity in today's growing eCommerce market. Rick Manelius  will review all of the parts of the standard that apply to Drupal along with providing efficient advice on how to best reduce one's risk when processing credit cards. As the amount of eCommerce transactions continues to rise it becomes even more critical to support every part in the system. If you would like more information on PCI compliance for Drupal  visit DrupalPCICompliance.org you can also download the free, community sponsored white paper.

The SCSSy Wild West: Partial Organization for a Complete Site

Take a look at Tim’s blog Partial to Partials: BoF Recap for a recap of last years session about the organization of partials.This year Tim Whitney  will go over a partial layout strategy for all scales of Drupal and non Drupal. Going over common pain points of SCSS partials and how to alleviate them while including approaches to help make life a little easier for everyone.

Integration Testing with KitchenCI & Multiple Provisioners

“Works on my machine” is no longer an acceptable reason for a Drupal site to not perform as expected across multiple environment (i.e. production, staging, development, and local development). This is particularly important as projects become larger, more complex, and have stringent requirements on performance, uptime, and security. Kevin Bridge's presentation will start with the basics of “Infrastructure as Code” and then quickly ramp up to review how to use provisioning tools and integration tests to ensure your infrastructure is achieving the desired state.

Intro to Frontend Ops

Discover the tools that help frontend developers stay consistent as they develop their drupal themes. This discussion from Ryan McVeigh will focus on gruntjs and bower and will also discuss Gulp JS, Phantomjs, PageSpeed, and Slimer JS. You will be able to watch some of his pre-recorded demos of the tools in action. Come and join in on the  discussion and see how the use of these various tools can contribute to your routine work day.

Come Join Us!

There is still time to sign up for this weekend and better yet it is free with the option to donate.  Any registration contributions beyond DrupalCamp Colorado’s  budget target will be donated to 3 charities: The Ada Initiative, Code.org, and Electronic Frontier Foundation.  This weekend has a  great full-day Training Day on August 1st and will be offering three separate classes you can pay and sign up for.

Categories: FLOSS Project Planets

Another Drop in the Drupal Sea: Ways to shoot yourself in the foot: element validation

Planet Drupal - Thu, 2014-07-24 23:21

I needed to do some custom validation of fields on a form. So, I decided to use #element_validate. One of the fields I was validating appeared a bit strange to me, though. When I displayed its $form_state['values']['field_face_palm'] information I saw that it looked like:

$field_face_palm['und'] = 'you_knucklehead'

instead of like:

$field_face_palm['und'][0]['value'] = 'you_knucklehead'

read more

Categories: FLOSS Project Planets

Gunnar Wolf: Nice read: «The Fasinatng … Frustrating … Fascinating History of Autocorrect»

Planet Debian - Thu, 2014-07-24 23:18

A long time ago, I did some (quite minor!) work on natural language parsing. Most of what I got was the very basic rudiments on what needs to be done to begin with. But I like reading some texts on the subject every now and then.

I am also a member of the ACM — Association for Computing Machinery. Most of you will be familiar with it, it's one of the main scholarly associations for the field of computing. One of the basic perks of being an ACM member is the subscription to a very nice magazine, Communications of the ACM. And, of course, although I enjoy the physical magazine, I like reading some columns and articles as they appear along the month using the RSS feeds. They also often contain pointers to interesting reads on other media — As happened today. I found quite a nice article, I think, worth sharing with whoever thinks I have interesting things to say.

They published a very short blurb titled The Fasinatng … Frustrating … Fascinating History of Autocorrect. I was somewhat skeptical reading it links to an identically named article, published in Wired. But gave it a shot, anyway...

The article follows a style that's often abused and not very amusing, but I think was quite well done: The commented interview. Rather than just drily following through an interview, the writer tells us a story about that interview. And this is the story of Gideon Lewis-Kraus interviewing Dean Hachamovitch, the creator of the much hated (but very much needed) autocorrect feature that appeared originally in Microsoft Word.

The story of Hachamovitch's work (and its derivations, to the much maligned phone input predictors) over the last twenty-something years is very light to read, very easy to enjoy. I hope you find it as interesting as I did.

Categories: FLOSS Project Planets

Plasma’s Road to Wayland

Planet KDE - Thu, 2014-07-24 22:28

With the Plasma 5.0 release out the door, we can lift our heads a bit and look forward, instead of just looking at what’s directly ahead of us, and make that work by fixing bug after bug. One of the important topics which we have (kind of) excluded from Plasma’s recent 5.0 release is support for Wayland. The reason is that much of the work that has gone into renovating our graphics stack was also needed in preparation for Wayland support in Plasma. In order to support Wayland systems properly, we needed to lift the software stack to Qt5, make X11 dependencies in our underlying libraries, Frameworks 5 optional. This part is pretty much done. We now need to ready support for non-X11 systems in our workspace components, the window manager and compositor, and the workspace shell.

Let’s dig a bit deeper and look at at aspects underlying to and resulting from this transition.

Why Wayland?

The short answer to this question, from a Plasma perspective, is:

  • Xorg lacks modern interfaces and protocols, instead it carries a lot of ballast from the past. This makes it complex and hard to work with.
  • Wayland offers much better graphics support than Xorg, especially in terms of rendering correctness. X11′s asynchronous rendering makes it impossible to be sure about correctness and timeliness of graphics that ends up on screen. Instead, Wayland provides the guarantee that every frame is perfect
  • Security considerations. It is almost impossible to shield applications properly from each other. X11 allows applications to wiretap each other’s input and output. This makes it a security nightmare.

I could go deeply into the history of Xorg, and add lots of technicalities to that story, but instead of giving you a huge swath of text, hop over to Youtube and watch Daniel Stone’s presentation “The Real Story Behind Wayland and X” from last year’s LinuxConf.au, which gives you all the information you need, in a much more entertaining way than I could present it. H-Online also has an interesting background story “Wayland — Beyond X”.

While Xorg is a huge beast that does everything, like input, printing, graphics (in many different flavours), Wayland is limited by design to the use-cases we currently need X for, without the ballast.
With all that in mind, we need to respect our elders and acknowledge Xorg for its important role in the history of graphical Linux, but we also need to look beyond it.

What is Wayland support?

KDE Frameworks 5 apps under Weston

Without communicating our goal, we might think of entirely different things when talking about Wayland support. Will Wayland retire X? I don’t think it will in the near future, the point where we can stop caring for X11-based setups is likely still a number of years away, and I would not be surprised if X11 was still a pretty common thing to find in enterprise setups ten years down the road from now. Can we stop caring about X11? Surely not, but what does this mean for Wayland? The answer to this question is that support for Wayland will be added, and that X11 will not be required anymore to run a Plasma desktop, but that it is possible to run Plasma (and apps) under both, X11 and Wayland systems. This, I believe, is the migration process that serves our users best, as the question “When can I run Plasma on Wayland?” can then be answered on an individual basis, and nobody is going to be thrown into the deep (at least not by us, your distro might still decide to not offer support for X11 anymore — that is not in our hands). To me, while a quick migration to Wayland (once ready) is something desirable, realistically, people will be running Plasma on X11 for years to come. Wayland can be offered as an alternative at first, and then promote to primary platform once the whole stack matures further.

Where at we now?

With the release of KDE Frameworks 5, most of the issues in our underlying libraries have been ironed out, that means X11-dependent codepaths have become optional. Today, it’s possible to run most applications built on top of Frameworks 5 under a Wayland compositor, independent from X11. This means that applications can run under both, X11 and Wayland with the same binary. This is already really cool, as without applications, having a workspace (which in a way is the glue between applications would be a pointless endeavour). This chicken-egg situation plays both ways, though: Without a workspace environment, just having apps run under Wayland is not all that useful. This video shows some of our apps under the Weston compositor. (This is not a pure Wayland session “on bare metal”, but one running in an X11 window in my Plasma 5 session for the purpose of the screen-recoding.)

For a full-blown workspace, the porting situation is a bit different, as the workspace interacts much more intimately with the underlying display server than applications do at this point. These interactions are well-hidden behind the Qt platform abstraction. The workspace provides the host for rendering graphics onto the screen (the compositor) and the machinery to start and switch between applications.

We are currently missing a number of important pieces of the full puzzle: Interfaces between the workspace shell, the compositor (KWin) and the display server are not yet well-defined or implemented, some pioneering work is ahead of us. There is also a number of workspace components that need bigger adjustments, global shortcut handling being a good example. Most importantly, KWin needs to take over the role of Wayland compositor. While some support for Wayland has already been added to KWin, the work is not yet complete. Besides KWin, we also need to add support for Wayland to various bits of our workspace. Information about attached screens and their layout has to be made accessible. Global keyboard shortcuts only support X11 right now. The screen locking mechanism needs to be implemented. Information about Windows for the task-manager has to be shared. Dialog positioning and rendering needs to be ported. There are also a few assumptions in startkde and klauncher that currently prevent them from being able to start a session under Wayland, and more bits and pieces which need additional work to offer a full workspace experience under Wayland.

Porting Strategy

The idea is to be able to run the same binaries under both, X11 and Wayland. This means that we (need to decide at runtime how to interact with the windowing system. The following strategy is useful (in descending order of preference):

  • Use abstract Qt and Frameworks (KF5) APIs
  • Use XCB when there are no suitable Qt and KF5 APIs
  • Decide at runtime whether to call X11-specific functions

In case we have to resort to functions specific to a display server, X11 should be optional both at build-time and at run-time:

  • The build of X11-dependent code optional. This can be done through plugins, which are optionally included by the build-system or (less desirably) by #ifdef’ing blocks of code.
  • Even with X11 support built into the binary, calls into X11-specific libraries should be guarded at runtime (QX11Info::isPlatformX11() can be used to check at runtime).
Get your Hands Dirty!

Computer graphics are an exciting thing, and many of us are longing for the day they can remove X11 from their systems. This day will eventually come, but it won’t come by itself. It’s a very exciting time to get involved, and make the migration happen. As you can see, we have a multitude of tasks that need work. An excellent first step is to build the thing on your system and try running, fix issues, and send us patches. Get in touch with us on Freenode’s #plasma IRC channel, or via our mailing list plasma-devel(at)kde.org.

Categories: FLOSS Project Planets

Shane Curcuru: Goodbye OSCON! See you next year!

Planet Apache - Thu, 2014-07-24 20:25

It was an amazing week at OSCON – so many great people to meet and share ideas with, both people I’d never met (some who knew me!) and plenty of old friends. Unfortunately I missed traveling out early to attend the Community Leadership Summit, a mistake I will not repeat next year – I’ll see folks there!

While my OSCON talk submissions on brand didn’t quite make the cut (they had an amazing number of great CFP submissions), I was lucky enough to present an OSCON Ignite 5-minute talk on Why your project’s brand is more important than the code, or BRAND > CODE. Since the slides for the 5 minute talk (they auto-advance every 15 seconds) are mostly graphics, I’ve posted my BRAND > CODE script as well.

Oh, hey, OSCON Ignite videos are already up – yay!

Giving the talk was great, but what was even better was the number of people who have come up during the conference who mentioned they liked it and/or that it opened their eyes to thinking about the bigger story that your project tells to the world.

Hope to see some more folks when I get to speak at ApacheCon Europe this November in Budapest – the conference schedule is now posted! And I’m hoping to be speaking at OSCON again next year as well!

Categories: FLOSS Project Planets

Justin Mason: Links for 2014-07-24

Planet Apache - Thu, 2014-07-24 19:58
Categories: FLOSS Project Planets

Cutelyst 0.3.0 is now C10K ready!

Planet KDE - Thu, 2014-07-24 19:18

Release early, release often has never been my strength especially since I don’t do a fair scheduling of all the projects I’m involved…

So since I was in need to better polish Cutelyst I took more time on it, and the result is great, around 100% speed up and a few new features added.

Cutelyst uWSGI plugin now has support for –thread, which will create a QThread to process a request, however I strongly discourage its usage in Cutelyst, the performance is ~7% inferior and a crash in your code will break other requests, and as of now ASYNC mode is not supported in threaded mode due to a limitation in uWSGI request queue.

Thanks to valgrind I managed to make a hello world application from 5K request per second on 0.2.0 to 10K req/s on 0.3.0 on an Intel Core2Duo 2.4Ghz (or 44K req/s on an AMD Phenom II 965 x4 3.4Ghz), however if you enable Grantlee templating you get around 600 req/s so if I happen to have time I will be looking into improving its performance.

Response::body() is now a QIODevice so you can set a QFile* of something else and have Cutelyst to send it back.

Now http://cutelyst.org points to a gitorious Wiki which is slowly getting populated, and API is available as http://api.cutelyst.org.

The 0.3.0 tarball can be downloaded here

Have fun :)


Categories: FLOSS Project Planets

Gael Varoquaux: The 2014 international scikit-learn sprint

Planet Python - Thu, 2014-07-24 18:59

A week ago, the 2014 edition of the scikit-learn sprint was held in Paris. This was the third time that we held an internation sprint and it was hugely productive, and great fun, as always.

Great people and great venues

We had a mix of core contributors and newcomers, which is a great combination, as it enables us to be productive, but also to foster the new generation of core developers. Were present:

  • Laurent Direr
  • Michael Eickenberg
  • Loic Esteve
  • Alexandre Gramfort
  • Olivier Grisel
  • Arnaud Joly
  • Kyle Kastner
  • Manoj Kumar
  • Balazs Kegl
  • Nicolas Le Roux
  • Andreas Mueller
  • Vlad Niculae
  • Fabian Pedregosa
  • Amir Sani
  • Danny Sullivan
  • Gabriel Synnaeve
  • Roland Thiolliere
  • Gael Varoquaux

As the sprint extended through a French bank holiday and the week end, we were hosted in a variety of venues:

  • La paillasse, a Paris bio-hacker space
  • INRIA, the French computer-science national research, and the place where I work
  • Criteo, a French company doing word-wide add-banner placement. The venue there was absolutely gorgeous, with a beautiful terrace on the roofs of Paris.
    And they even had a social event with free drinks one evening.
  • Tinyclues, a French startup mining e-commerce data.

I must say that we were treated like kings during the whole stay; each host welcoming us as well they could. Thank you to all of our hosts!

Sponsored by the Paris-Saclay Center for Data Science

Beyond our hosts, we need to thank the Paris-Saclay Center for Data Science. The CDS gave us funding that covered some of the lunches, acomodations, and travel expenses to bring in our
contributors from abroad.

Achievements during the sprint

The first day of the sprint was dedicated to polishing the 0.15 release, which was finally released on the morning of the second day, after 10 months of development.

A large part of the efforts of the sprint were dedicated to improving the coding base, rather than directly adding new features. Some files were reorganized. The input validation code was cleaned up (opening the way for better support of pandas structures in scikit-learn). We hunted dead code, deprecation warnings, numerical instabilities and tests randomly failing. We made the test suite faster, and refactored our common tests that scan all the model.

Some work of our GSOC student, Manoj Kumar, was merged, making some linear models faster.

Our online documentation was improved with the API documentation pointing to examples and source code.

Still work in progress:

  • Faster stochastic gradient descent (with AdaGrad, ASGD, and one day SAG)
  • Calibration of probabilities for models that do not have a ‘predict_proba’ method
  • Warm restart in random forests to add more estimators to an existing ensemble.
  • Infomax ICA algorithm.

Categories: FLOSS Project Planets

Drupal.org frontpage posts for the Drupal planet: Drupal 7.30 released

Planet Drupal - Thu, 2014-07-24 18:12

Drupal 7.30, a maintenance release with several bug fixes (no security fixes), including a fix for regressions introduced in Drupal 7.29, is now available for download. See the Drupal 7.30 release notes for a full listing.

Download Drupal 7.30

Upgrading your existing Drupal 7 sites is recommended. There are no new features in this release. For more information about the Drupal 7.x release series, consult the Drupal 7.0 release announcement.

Security information

We have a security announcement mailing list and a history of all security advisories, as well as an RSS feed with the most recent security advisories. We strongly advise Drupal administrators to sign up for the list.

Drupal 7 includes the built-in Update Manager module, which informs you about important updates to your modules and themes.

There are no security fixes in this release of Drupal core.

Bug reports

Drupal 7.x is being maintained, so given enough bug fixes (not just bug reports), more maintenance releases will be made available, according to our monthly release cycle.

Changelog

Drupal 7.30 is a bug fix only release. The full list of changes between the 7.29 and 7.30 releases can be found by reading the 7.30 release notes. A complete list of all bug fixes in the stable 7.x branch can be found in the git commit log.

Update notes

See the 7.30 release notes for details on important changes in this release.

Known issues

None.

Front page news: Planet DrupalDrupal version: Drupal 7.x
Categories: FLOSS Project Planets

Node.js support in KDevelop

Planet KDE - Thu, 2014-07-24 18:00

This is a quick blog post to say that I’m working on support for the Node.js framework by the KDevelop QML/JS language plugin. The first part of my work is already finished: “require” is properly recognized and Node.js modules are properly looked-up and included. The “exports” and “module.exports” identifiers are also recognized and allow Javascript files to export symbols and to be used as modules. This means that you can now edit Javascript files using Node.js and have most of the modules recognized, included and parsed.

The second part is writing huge Javascript files for the built-in Node.js modules. “http”, “buffer”, “fs”, “url” and many other modules exist only as part of Node.js. There are Javascript files for them in the Node.js Git repository, but these files don’t allow the QML/JS plugin to infer the types of the methods. They are also fairly big and would need a big cleanup in order to be fast enough to parse.

As with ECMAScript, I solve the problem by shipping with QML/JS stripped down versions of those files. These files describe the classes, methods and attributes of each module, and follow a very simple format. This code is not designed to be run, only to be parsed by the QML/JS plugin, that will discover the types of the function parameters and their return type.

1 2exports.spawn = function (command, args, options) { return new exports.ChildProcess(); }; exports.spawn("", [], new Object());

Writing all these files is tiring and will take some time (in fact, I’m writing them for a bit more than one day, now). So, there may be fewer commit than usual in the QML/JS repository, but I hope that this feature will serve many users. Here is a teaser of what is coming (note that functions are now listed in a way more human-friendly form):

Once this feature is finished, I will concentrate my efforts on the QML code-completion. I’ll also experiment with the KDE Frameworks 5 (and the KF5 version of KDevelop), because I’d like to offer a KF5 version of the QML/JS plugin. The reason is twofold: Qt5 offers the wonderful QtQuick.Controls module (it will allow me to implement many navigation widget, that will assist the users in choosing a font family, configuring and previewing animations, etc), and early KF5/Plasma5 adopters may be well pleased to be able to use the latest and greatest KDevelop on their latest and greatest environment, while still being able to work on QML and Javascript files.

UPDATE: Here is an additional screenshot that shows that child_process.ChildProcess is correctly recognized, and that it correctly inherits from event.EventEmitter (you see that addListener is in the list), which in turn inherits from Object (there is an “assign” method at the very bottom of the list). Having all of this working was a bit more difficult than expected, but now function prototypes and class inheritance seem to work.

Categories: FLOSS Project Planets

Mediacurrent: Code Review for Non-Technical Folks

Planet Drupal - Thu, 2014-07-24 17:07

Andrew Riley leads us through a high level walkthrough of what Code Reviews are and why we need them. In this talk he covers what we check for at Mediacurrent (syntax, security, efficiency etc) and why code reviews are important for our customers and any company that writes their own code.

Additional Resources

Drupal 8 In Pictures (for Users) | Mediacurrent Blog

Categories: FLOSS Project Planets

A wild "monday" report appears …

Planet KDE - Thu, 2014-07-24 15:32
Arguably our insanely-coolest member, Philipp Stefan contributed this "monday" report.Yes, it has been some time since the last entry, but with the Plasma 5 release and Jens’ busy work schedule there hasn’t been much time for him to write one, unfortunately. I hope I can keep you up to date more regularly from now on. So let’s dive right in:

What’s being worked onThe work on revisiting and expanding the Human Interface Guideline on tooltips has begun. If there’s something that has always bothered you about how tooltips in KDE Applications and Plasma look and feel consider to join in. The work is still in its early stages, so now would be the best time to voice your concerns. [https://forum.kde.org/viewtopic.php?f=285&t=121892]

Martin Gräßlin has started to work on a new window decoration API for KWin and is also working to port the Breeze window decoration to C++. This should bring the necessary performance boost to make Breeze the default window theme in future releases. We can also expect one feature many love in Oxygen to be present in the new Breeze implementation: window tabs. The awesome community member EraX has stepped up and made some mockups of how window tabs could look like in Breeze.

If you have other ideas and feedback, consider to chime in!Additionally Martin has created some tasks you can take up to help us out porting Breeze to C++. Take a look at Martin’s blog post for more information [http://blog.martin-graesslin.com/blog/2014/07/kdecoration2-the-road-ahead/]

Behind the scenes Jens Reuteberg and Heiko Tietze has started to collect information for animation guidelines. If you have an expertise in this area or are just generally interested and want to help us out try to contact them. [https://forum.kde.org/viewtopic.php?f=285&t=121993]

We migrated to KDE’s new todo-board infrastructure, todo.kde.org. It’s really nice having everything consolidated in one place and accessible with one’s KDE-Identity account. In future we also hope to migrate away from Google Docs and Hangouts. We have been looking into something like an OwnCloud installation to create, share and store documents. Nothing is written in stone though and frankly we’ve got more important things to do right now.  

What has been overlookedWe have noticed that the participation rate in the VDG forums has plummeted and only a small core has remained, which are doing awesome work! It has to be expected that participation rates decline at the end of every release cycle, when all the work gets finalized there’s not much to be discussed after all. Nethertheless, we’d like to recreate the same experience we had with the KMyMoney, the window decoration, the widget and the cursor theme.We identified several causes that could have contributed to the decline in participation:
  • Back then the VDG forum was new – people simply got disinterested over time
  • The VDG hasn’t communicated as much as in the beginning – the process became less transparent
  • There has not been as much guidance in where to start helping out as in the beginning
We try to address these issue better from now on. We have reorganized ourselves a bit, so you can expect more blog entries from more VDG members in future. We also intend to open new “challenges” (not in the sense of a contest) at the beginning of each release cycle where the community can participate in.Please tell us if you have ideas how we can foster a more vibrant design community in KDE, critique happily appreciated. We also have a thread in the forums about a related issue. If you feel the same way consider to leave a comment.
Overall I can only encourage you to browse the VDG forum. There are many interesting threads that could need some community love.
Categories: FLOSS Project Planets

Forum One: Drupal 8 Code Sprint at the Jersey Shore

Planet Drupal - Thu, 2014-07-24 14:52

On the heels of our own Drupal 8 code sprint in DC, I spent the last weekend with the New Jersey Drupal group who organized a Drupal 8 code sprint in Asbury Park, NJ – and although I was never greeted by The Boss, I was pleased to participate thanks to the generosity of the event organizers.

Issue-Focused

I worked on the MenuLink NG part 1 issue extensively with Peter Wolanin and YesCT. This issue is part of the [Meta] New plan, Phase 2 issue which proposed performance improvement and UI improvement in Drupal 8. This issue originally had a 600KB patch, but to make it more reviewable/committable the issue was split into five child issues.

Three of us spent a solid two days and more than 30 hours addressing every single point that had been raised by reviewers – and which had been holding up the process of adding this to Core.

Image courtesy of Blink Reaction

About this Issue (a high level overview)

A site builder or developer can create menu links in Drupal via configuration by changing the weight, position, creating links in menu, or in code. All these different types of menu links need to be rendered together in menus, so that they present the same in the API to developers. The developer experience on this issue needs to be easy, as almost everything depends on menu items.

While we toiled on this issue, other sprinters worked on DrupalCon Austin’s Consensus Banana, testing the migration path from Drupal 6 to Drupal 7, along with some other issues.

Results and Commits

The sprint was a very productive one, and resulted in Menu part 1 and Menu part 2 being committed to Core, which was a beta-blocker issue. As of this sprint there were seven beta-blocker issues, but solving the Menu issue helps to put us one step closer to the Drupal 8 Beta release!

For those interested, here are the commits for part 1 and part 2. And for those needing a chuckle, Alex “The Situation” Pott – who thankfully preferred DCC (Drupal Core Commits) over GTL (Gym, Tan, Laundry) – drew this goaty looking lama to celebrate his commit

Image courtesy of Blink Reaction

It was very rewarding to work for a weekend with this group of talented developers, and I think we all left the shore content in the knowledge that we’d made strides toward bringing Drupal 8 that much closer to completion.

Check out these other pictures taken by Peter Wolanin and DrupalCamp NJ at the event »

Categories: FLOSS Project Planets

Kate “master” branch now KF5 based!

Planet KDE - Thu, 2014-07-24 14:18

Hi,

from today on, the master branch of kate.git is KF5 based.

That means, for the next KDE applications release after 4.14, Kate will use the awesome KF5 stuff!

The KTextEditor framework is already in a good shape and most active KatePart development is since months pure KF5 based.

The same should now be true for Kate itself (and KWrite).

Pâté will need a lot of love, as PyQt5 is there, but PyKDE5/PyKF5 still in the works.

Happy hacking, help us to make KF5 based Kate awesome, too.

For 4.14: keep fixing bugs, but all new shiny stuff that might regress things really should only go into our KF5 based master branch!

Categories: FLOSS Project Planets

Data Community DC: Building Data Apps with Python on August 23rd

Planet Python - Thu, 2014-07-24 14:16

Data Community DC and District Data Labs are excited to be hosting another Building Data Apps with Python workshop on August 23rd.  For more info and to sign up, go to http://bit.ly/V4used.  There’s even an early bird discount if you register before the end of this month!

Overview

Data products are usually software applications that derive their value from data by leveraging the data science pipeline and generate data through their operation. They aren’t apps with data, nor are they one time analyses that produce insights – they are operational and interactive. The rise of these types of applications has directly contributed to the rise of the data scientist and the idea that data scientists are professionals “who are better at statistics than any software engineer and better at software engineering than any statistician.”

These applications have been largely built with Python. Python is flexible enough to develop extremely quickly on many different types of servers and has a rich tradition in web applications. Python contributes to every stage of the data science pipeline including real time ingestion and the production of APIs, and it is powerful enough to perform machine learning computations. In this class we’ll produce a data product with Python, leveraging every stage of the data science pipeline to produce a book recommender.

What You Will Learn

Python is one of the most popular programming languages for data analysis.  Therefore, it is important to have a basic working knowledge of the language in order to access more complex topics in data science and natural language processing.  The purpose of this one-day course is to introduce the development process in Python using a project-based, hands-on approach. In particular you will learn how to structure a data product using every stage of the data science pipeline including ingesting data from the web, wrangling data into a structured database, computing a non-negative matrix factorization with Python, then producing a web based report.

Course Outline

 The workshop will cover the following topics:

  • Basic project structure of a Python application

  • virtualenv & virtualenvwrapper

  • Managing requirements outside the stdlib

  • Creating a testing framework with nose

  • Ingesting data with requests.py

  • Wrangling data into SQLite Databases using SQLAlchemy

  • Building a recommender system with Python

  • Computing a matrix factorization with Numpy

  • Storing computational models using pickles

  • Reporting data with JSON

  • Data visualization with Jinja2

After this course you should understand how to build a data product using Python and will have built a recommender system that implements the entire data science pipeline.

Instructor: Benjamin Bengfort

Benjamin is an experienced Data Scientist and Python developer who has worked in military, industry, and academia for the past eight years. He is currently pursuing his PhD in Computer Science at The University of Maryland, College Park, doing research in Metacognition and Active Logic. He is also a Data Scientist at Cobrain Company in Bethesda, MD where he builds data products including recommender systems and classifier models. He holds a Masters degree from North Dakota State University where he taught undergraduate Computer Science courses. He is also adjunct faculty at Georgetown University where he teaches Data Science and Analytics.

The post Building Data Apps with Python on August 23rd appeared first on Data Community DC.

Categories: FLOSS Project Planets

Sagara Gunathunga: WebSocket security patterns

Planet Apache - Thu, 2014-07-24 14:02
WebSocket protocol introduced "wss" prefix to define secure web socket connections that is for transport level security (TLS).  But it does not define any authentication or Authorization  mechanism, instead it is possible to reuse existing HTTP based authentication/Authorization mechanisms during the handshake phase.  
Here I discuss two security patterns that can be used to connect secure WebSocket endpoint from a client. Assume WebSocket endpoint is secured with HTTP BasicAuth while HTTP/SSL used for transport level security.  

1. ) Browser based clients 
For web browser based clients most popular choice is to use JavaScript API for WebSocket but this API does not provide any approach to send "Authorization" or any other headers along with the handshake request. Following pattern can be used  to overcome above issue. 


The technique we use here is secure the web page where we run JS WebSocket client through BasicAuth security. Please refer the message flow. 

1. User access the secure page through a web browser through HTTPS. 
2. Since the page is secured web server return 401 status code.
3. Browser challenges user to enter valid user name and password then send them as a encoded value with  "Authorization" header. 
4. If credentials are correct server returns secure page. 
5. JS WebSocket client on secured page send handshake request to the secured remote WebSocket endpoint through WSS protocol. Due to previous interaction with the same page browser persist and send authorization details along with the handshake request. 

6. Since handshake request transmit through HTTPS it fulfil the both requirements, BasicAuth and TLS. Server returns handshake response back to the client.   
7. Now it's possible to establish WebSocket connection among above two parties. 



2.) Agent based client (Non browser based)
For agent based clients you could use a WebSocket framework which facilitate  to add authentication headers and also to configure SSL configuration such as key store.  Following diagram illustrate a pattern which we be can used with agents based clients. 


1. Using the client side API of the WebScoket framework create a handshake request. 
2. Set Authorization header and other required key store information for TLS. 
3. Send  handshake request through WebSocket framework API. 
4. Server receive handshake and Authorization header  through HTTPS . Validate the header and if valid  send the handshake response back to the client. 
5. Now it's possible to establish WebSocket connection among above two parties. 
As an example Java API for WebSocket  allows to send custom headers  along with handshake request by writing a custom Configurator which extend from  ClientEndpointConfig.Configurator
Here is such example.

public class ClientEndpointConfigurator extends
ClientEndpointConfig.Configurator {
@Override
public void beforeRequest(Map<String, List<String>> headers) {
String auth = "Basic " +
Base64Utils.encodeToString("user:pass".getBytes(Charset.forName("UTF-8")), false);
headers.put("Authorization", Arrays.asList(new String[]{auth }));
super.beforeRequest(headers);
}
}


Once you wrote this ClientEndpointConfigurator you can refer it from Client endpoint using  'ClientEndpoint' annotation as follows. 
 @ClientEndpoint(configurator=ClientEndpointConfigurator.class)
public class EchoClientEndpoint { ........................ }



By the way there is no portable API to define SSL configurations required for TLS but some framework such as  Tyrus provides proprietary APIs . As an example refer how this facilitated in Tyrus through ClientManager API.




Categories: FLOSS Project Planets

Let’s party!

Planet KDE - Thu, 2014-07-24 13:10

Yesterday, we released ownCloud 7. You might have read that somewhere on the internet – it was widely announced and broadly picked up. If you do not have ownCloud yet, you really should try it now, and if you are one of the people happily using ownCloud for a while, update soon!

In my opinion, ownCloud 7 is a real step ahead. So much work went into it from the brave server guys, and the result is simply impressive: It is fast, beautiful and fully focused on what it is supposed to be and do: File sync and share, even though you still have of course all the other useful stuff like calendaring and such.

Apart from the wellknown features ownCloud 7 also brings some things that you do not see on the first look. Some of these things relate to syncing and as a guy working mainly on the sync client I am especially happy about that: Already with the current released clients you will see a performance win in syncing, because ownCloud 7 handles parallel HTTP requests way better. Moreover, ownCloud 7 sends some interesting information about it’s files, and the next generation of sync clients will for example know which files are shared and their permissions. We are currently working on some exciting stuff on the client side, stay tuned.

That all should be reason enough to celebrate together, because ownCloud is done by all of us in the community.

On Tuesday, august 5th, we will do a Release Party in Nuremberg, Germany. As last time, the Coworkingspace Nürnberg is hosting us. We will start at 18:00.

Everybody who is interested in ownCloud for whatever reason is very welcome to show up. We will probably have a short informal demonstration or two, but of course plenty room for questions, discussions, meet and greet with all kind of FOSS people, some core ownCloud people, nice beer and big fun.

You really should come! And don’t forget to tell your friends, thanks!


Categories: FLOSS Project Planets

Logilab: EP14 Pylint sprint Day 1 report

Planet Python - Thu, 2014-07-24 10:51

We've had a fairly enjoyable and productive first day in our little hidden room at EuroPython in Berlin ! Below are some noticeable things we've worked on and discussed about.

First, we discussed and agreed that while we should at some point cut the cord to the logilab.common package, it will take some time notably because of the usage logilab.common.configuration which would be somewhat costly to replace (and is working pretty well). There are some small steps we should do but basically we should mostly get back some pylint/astroid specific things from logilab.common to astroid or pylint. This should be partly done during the sprint, and remaining work will go to tickets in the tracker.

We also discussed about release management. The point is that we should release more often, so every pylint maintainers should be able to do that easily. Sylvain will write some document about the release procedure and ensure access are granted to the pylint and astroid projects on pypi. We shall release pylint 1.3 / astroid 1.2 soon, and those releases branches will be the last one supporting python < 2.7.

During this first day, we also had the opportunity to meet Carl Crowder, the guy behind http://landscape.io, as well as David Halter which is building the Jedi completion library (https://github.com/davidhalter/jedi). Landscape.io runs pylint on thousands of projects, and it would be nice if we could test beta release on some part of this panel. On the other hand, there are probably many code to share with the Jedi library like the parser and ast generation, as well as a static inference engine. That deserves a sprint on his own though, so we agreed that a nice first step would be to build a common library for import resolution without relying on the python interpreter for that, while handling most of the python dark import features like zip/egg import, .pth files and so one. Indeed that may be two nice future collaborations!

Last but not least, we got some actual work done:

  • Michal Novikowsky from Intel in Poland joined us to work on the ability to run pylint in different processes so it may drastically improve performance on multiple cores box.
  • Torsten did continue some work on various improvements of the functionnal test framework.
  • Sylvain did merge logilab.common.modutils module into astroid as it's mostly driven by astroid and pylint needs. Also fixed the annoying namespace package crash.
  • Claudiu keep up the good work he does daily at improving and fixing pylint :)
Categories: FLOSS Project Planets
Syndicate content