Agrégateur de flux

Gábor Hojtsy: The Drupal 8 configuration schema cheat sheet

Planet Drupal - ven, 12/12/2014 - 11:20

After over a month of concentrated work, Drupal 8 was ready today to finally flip the switch and enforce strict configuration schema adherence in all TestBase derived tests in core. See the announcement in the core group.

If you are a Drupal 8 contrib developer and provided some configuration schema earlier (or you integrate with an existing core system like blocks, views, fields, etc.) then your tests may now fail with configuration schema errors. Unless of course all your configuration schema is correct: #highfive for you then.

Otherwise I thought you'll have questions. There is of course the existing configuration schema documentation that I helped wrote. However if you are a visual person and want to get an understanding of the basics fast, I thought a cheat sheet would be a great tool. So sat down today and produced this one in the hopes it will help you all! Enjoy!

Catégories: Elsewhere

EvolvisForge blog: Tip of the day: don’t use –purge when cross-grading

Planet Debian - ven, 12/12/2014 - 10:04

A surprise to see my box booting up with the default GRUB 2.x menu, followed by “cannot find a working init”.

What happened?

Well, grub:i386 and grub:x32 are distinct packages, so APT helpfully decided to purge the GRUB config. OK. Manual boot menu entry editing later, re-adding “GRUB_DISABLE_SUBMENU=y” and “GRUB_CMDLINE_LINUX=”syscall.x32=y”” to /etc/default/grub, removing “quiet” again from GRUB_CMDLINE_LINUX_DEFAULT, and uncommenting “GRUB_TERMINAL=console”… and don’t forget to “sudo update-grub”. There. This should work.

On the plus side, nvidia-driver:i386 seems to work… but not with boinc-client:x32 (why, again? I swear, its GPU detection has been driving me nuts on >¾ of all systems I installed it on, already!).

On the minus side, I now have to figure out why…

tglase@tglase:~ $ sudo ifup -v tap1
Configuring interface tap1=tap1 (inet)
run-parts –exit-on-error –verbose /etc/network/if-pre-up.d
run-parts: executing /etc/network/if-pre-up.d/bridge
run-parts: executing /etc/network/if-pre-up.d/ethtool
ip addr add 192.168.0.3/255.255.255.255 broadcast 192.168.0.3 peer 192.168.0.4 dev tap1 label tap1
Cannot find device “tap1″
Failed to bring up tap1.

… this happens. This used to work before the cktN kernels.

Catégories: Elsewhere

Blair Wadman: Programmatically assign roles to users in Drupal

Planet Drupal - ven, 12/12/2014 - 09:24

This post is part of a series of posts on making changes in Drupal programmatically rather than in the Drupal interface.

In this tutorial, we will be programmatically assigning role(s) to user(s). You would typically do this in a site deployment module in order to automate this task rather than having to manually assign the roles in the Drupal UI.

Catégories: Elsewhere

Joey Hess: a brainfuck monad

Planet Debian - ven, 12/12/2014 - 06:02

Inspired by "An ASM Monad", I've built a Haskell monad that produces brainfuck programs. The code for this monad is available on hackage, so cabal install brainfuck-monad.

Here's a simple program written using this monad. See if you can guess what it might do:

import Control.Monad.BrainFuck demo :: String demo = brainfuckConstants $ \constants -> do add 31 forever constants $ do add 1 output

Here's the brainfuck code that demo generates: >+>++>+++>++++>+++++>++++++>+++++++>++++++++>++++++++++++++++++++++++++++++++<<<<<<<<[>>>>>>>>+.<<<<<<<<]

If you feed that into a brainfuck interpreter (I'm using hsbrainfuck for my testing), you'll find that it loops forever and prints out each character, starting with space (32), in ASCIIbetical order.

The implementation is quite similar to the ASM monad. The main differences are that it builds a String, and that the BrainFuck monad keeps track of the current position of the data pointer (as brainfuck lacks any sane way to manipulate its instruction pointer).

newtype BrainFuck a = BrainFuck (DataPointer -> ([Char], DataPointer, a)) type DataPointer = Integer -- Gets the current address of the data pointer. addr :: BrainFuck DataPointer addr = BrainFuck $ \loc -> ([], loc, loc)

Having the data pointer address available allows writing some useful utility functions like this one, which uses the next (brainfuck opcode >) and prev (brainfuck opcode <) instructions.

-- Moves the data pointer to a specific address. setAddr :: Integer -> BrainFuck () setAddr n = do a <- addr if a > n then prev >> setAddr n else if a < n then next >> setAddr n else return ()

Of course, brainfuck is a horrible language, designed to be nearly impossible to use. Here's the code to run a loop, but it's really hard to use this to build anything useful..

-- The loop is only entered if the byte at the data pointer is not zero. -- On entry, the loop body is run, and then it loops when -- the byte at the data pointer is not zero. loopUnless0 :: BrainFuck () -> BrainFuck () loopUnless0 a = do open a close

To tame brainfuck a bit, I decided to treat data addresses 0-8 as constants, which will contain the numbers 0-8. Otherwise, it's very hard to ensure that the data pointer is pointing at a nonzero number when you want to start a loop. (After all, brainfuck doesn't let you set data to some fixed value like 0 or 1!)

I wrote a little brainfuckConstants that runs a BrainFuck program with these constants set up at the beginning. It just generates the brainfuck code for a series of ASCII art fishes: >+>++>+++>++++>+++++>++++++>+++++++>++++++++>

With the fishes^Wconstants in place, it's possible to write a more useful loop. Notice how the data pointer location is saved at the beginning, and restored inside the loop body. This ensures that the provided BrainFuck action doesn't stomp on our constants.

-- Run an action in a loop, until it sets its data pointer to 0. loop :: BrainFuck () -> BrainFuck () loop a = do here <- addr setAddr 1 loopUnless0 $ do setAddr here a

I haven't bothered to make sure that the constants are really constant, but that could be done. It would just need a Control.Monad.BrainFuck.Safe module, that uses a different monad, in which incr and decr and input don't do anything when the data pointer is pointing at a constant. Or, perhaps this could be statically checked at the type level, with type level naturals. It's Haskell, we can make it safer if we want to. ;)

So, not only does this BrainFuck monad allow writing brainfuck code using crazy haskell syntax, instead of crazy brainfuck syntax, but it allows doing some higher-level programming, building up a useful(!?) library of BrainFuck combinators and using them to generate brainfuck code you'd not want to try to write by hand.

Of course, the real point is that "monad" and "brainfuck" so obviously belonged together that it would have been a crime not to write this.

Catégories: Elsewhere

Bluespark Labs: 10 Challenges You Face when Designing for Locations

Planet Drupal - ven, 12/12/2014 - 06:00

Designing a website for an organization with multiple locations is challenging. Especially when those locations have their own needs, goals, and identities. Libraries, in all shapes and sizes, face many challenges when building or redesigning their website. They need to build something that students and patrons can use for research as well as something that actually helps people interact with the library’s various locations. This becomes especially difficult when the library is spread across several buildings and departments — and the people that work at the different libraries often have very different ideas about how their library should be represented on the Web.

Building a great library website is an ambitious project with the ultimate goal of serving the students, faculty, staff, and community.

On the surface, building a library website might feel like just another web project, but when you dig into it, you see there are many, many unique challenges stemming from the unique relationship the library has with it’s virtual and physical spaces. In this article, I explore 10 of those challenges and some possible solutions. Like any web project, though, every situation is unique. I prefer to focus on guidelines and considerations rather than describe actual solutions.

Challenge #1 - Who is our primary audience and what is their context of use?

What’s interesting about Universities—and Libraries fall victim to this, too—there are plenty of audiences to go around and each of their needs must be met for the website to be considered a success. Unfortunately, having too many audiences is like having too many cooks—you end up with something bland that no one likes.

Once you know who your primary audience is, you can explore their Contexts of Use. Contexts of Use are the place, time, and situation in which they will be using the website.

  • When will they need help finding a location?

  • What in the space are they looking for? (A building? Equipment? Something else?)

  • Where are they when they need to find that location?

Sidenote: When we talk about audiences, we also often talk about their goals. Multiple audiences might have similar goals. (How many audiences for a University Library have “Conduct independent research” as a primary goal?) Contexts of Use, though, differentiate these goals across the audiences. A student who needs to conduct independent research at the library website will approach it differently than a faculty member.

So why are contexts of use important? Well, they reveal things like why people are searching for a location (meeting a group, or maybe they need a copy machine, or maybe they want a quiet place to study) and allow you to design experiences for those contexts.

Challenge #2 - Are we a library? Or do we have libraries?

University Libraries are spread all over campus. There’s almost always “The Library” — the one building that everyone thinks about when you tell them to meet you at “The Library” but that is probably just one location of many.

Not to mention the many affiliated libraries—the independent collections managed by departments—the literature collection tucked away in the basement of the Humanities building. How are these related to the library and does your audience understand that relationship? Often this is a question much bigger than a website design project—venturing into your overall strategy, but the answer (and its trickle down effects) can hinder or help your audience accomplish its goals.

And all that leads to the question: Are you a University Library—or are you the University Libraries? It’s an identity question that affects your brand, the representation of that brand online, and the freedom you give the individual libraries.

Challenge #3 - Libraries are not Buildings

Repeat after me: Libraries are not buildings. For some of your libraries, this is painfully obvious. A special collection might be tucked into the corner of a building—be considered its own department, have its own hours and staff. That library is located within a building.

For other libraries, though, it’s less obvious. For example, at the UCLA Library, the Powell Library is located in the Powell Library building, but so are several special collections. You see the confusion? In the physical world, libraries have a special connection to the information they hold—that is the only place you can access that information. It goes without saying that, in the virtual world, these boundaries no longer exist. But because our understanding of physicality (that, and the trend of naming a building after its current use) lead to a tendency to conflate the actual library with the building that houses it.

Where it becomes painfully obvious is when a library is spread across multiple buildings—something that can often happen in space-starved Universities. (And let’s be honest, no matter how large the University, there is always a need for more space.)

There are several key instances when confusing the building with the library will actually create project over-runs. Buildings need to be managed separately from the libraries. The buildings, like the libraries themselves, may have unique names and will definitely have physical locations.

Even more challenging, though, is that this misunderstanding can also lead to poor decision-making about how to structure content. Just like the books and journals of a library live within the physical walls of building, some library staff might think their content should live within the virtual walls of their particularly library’s sitelet. This is where having well-defined persona with prioritized goals and contexts of use become critical to the success of the project. You can use these to explore whether people are first finding a specific library before beginning their search OR are they expecting to search for relevant research from a centralized research section OR something else entirely. (And, of course, stir in a healthy dose of usability testing to verify your hypothesis.)

Challenge #4 - Finding the right location

Here’s a fun one.

How do you know people are getting the right location?

It’s easy when you have a library called The Humanities Library and people are searching for the Humanities Library. But what happens when you have The John Doe Library of the Humanities and people refer to it as the Hum. Or some people call it the Hum and others call it the Humanities Library. It can get confusing real quick if you don’t have an option to add nicknames to your libraries (add nicknames to your buildings while you’re at it, too).

Challenge #5- When the library doesn’t matter, but the location does...

Finding a location is pretty easy when people are searching for a specific location—whether that be a library or a building. But there are plenty of contexts in which a user needs something that is location-agnostic.

Maybe they need a copier or a printer or a computer. Most libraries will have copiers spread all over campus—and some with different pricing. Keeping track of all the amenities that each location offers can be no easy task, but can go a long way to helping your audience actually get what they need from the library.

Tip: Think beyond equipment and things like wifi. Do some libraries offer study rooms? Or some places might offer a group study area where you don’t need to keep your voice down. These are all important amenities that people will be looking for. Taking note of the questions your students are asking about your locations will give you insight into the types of amenities you should be offering and how you should be categorizing your various locations.

Challenge # 6 - Is it open?

One of the biggest challenges seems like it would be the simplest. Students (and all of your audiences, really) need to know one of two things: 1) Is it open now? 2) Will it be open when I need it?

Of course, answering these questions is tricky. You’ve got your normal hours, your holiday hours, your end-of-the-semester hours, your summer hours—so many special circumstances, how do manage them all, much less present them to the user in an easy to read format? There’s really no simple answer other than to keep it as simple as possible and to conduct usability testing on sketches and prototypes with real users.

One of the useful, yet tricky, things we did with UCLA was to add “Open Now” as a search facet, so that all results returned only buildings that were open now—particularly useful for the students that needed a late night copy machine (context of use!) as well as including an “Open Now” indicator right in the location pages’ navigation bar.

Challenge #7 - Destinations within a location

“Is it open?” is not always an easy question to answer. Often, you will have destinations within a location that have separate hours than the main location. While the library will be open, the computer room might not be.

The solution we implemented for UCLA Library was to allow each location to have Destinations with their own descriptions, contact information, and hours. A future iteration of this should also include walking directions from various entrances—assuming that those entrances are clearly designated.

Challenge #8 - What’s going on at the Library?

Libraries host some great events that need to be listed on the website. There are, though, two challenges you face with events.

The first part of this challenge comes from conflating the building and the library as illustrated by this story:

Once upon a time, there was a librarian that worked at the Library of Biological Sciences. She took it upon herself to organize a lecture series from visiting scientists. The first event’s popularity took her by surprise; she had reserved the largest room in her library’s space, but it was still standing room only. So, for the second event, she opted to host the event at the Humanities Library who had a space twice the size of her largest space.

Challenge part 1: If the Library of Biological Sciences is hosting an event at the Humanities Library space, does the event display on the Library of Biological Sciences sitelet?

Challenge part 2: The Library of Biological Sciences is hosting an event at the Humanities Library space, should that event display on the Humanities Library sitelet?

And the answer (drumroll, please): it’s complicated. Ideally, it displays in both areas. Both libraries have an interest in promoting the event (and it should be the same content—not two different entries), though they have different reasons for doing so. The Library of Biological Sciences wants to promote an event they have spent a lot of time and resources organizing while the Humanities Library wants to let people know what’s going on in their space.

The real answer: It should be up to the sitelet moderators to determine what events they promote. They should have strong guidelines generated from Engagement and Content strategies, but the final decision comes from the autonomy you give the libraries themselves. (More on that to come.)

In the above challenge, the Library of Biological Sciences is hosting an event related to Biology in the Humanities Library space. It’s pretty clear cut as to why the two might want to promote the event. But what if the Humanities Library were to invite the author of a crime thriller that paid exquisite attention to the forensic details of the case—something that many people from the Library of Biological Sciences might be interested in? Should the event display on the Library of Biological Sciences sitelet?

The answer is not a simple one. Probably, yes, it should. Again, though, it should be up to the sitelet moderator who would be following Engagement and Content strategies.

Challenge #9 - Balancing autonomy and control

How unique are your locations? From the space they contain to the style of signage and posters used throughout the library. Maybe some of the smaller libraries don’t have a unique brand while the larger ones do. Or, perhaps, your library system has a style guide that all of your staff rigorously apply in everything they create.

Ideally you find a nice balance between command-and-control and complete anarchy. You want each location to feel part of the same family without taking away the things that make them feel unique. There are several ways to do this, including allowing each location to:

  • control the type of content they include on their homepage.

  • customize some of the visual styles on their page -- perhaps background image and other areas that can affect the basic feel of the site.

  • control the layout of their homepage.

You want to give your staff enough autonomy that they can ensure their library sitelet best represents the unique branding and style they have crafted in their space.

Challenge #10 - Consistency between the virtual and the physical

On the flip side of giving your staff autonomy, we have the need to give your audiences a consistent experience across locations and on the website. At its simplest, this means that you display the same information in the same way across sites. An event should look the same across all sites.

It goes deeper than this, though, even into the branding and labeling across your entire Library system, which is really a much larger project than the website redesign. But if you think about it (and I know librarians have!), a key part of finding your way through the physical location is the signage. As much as possible, you should create consistency between the signage in your spaces -- meaning that all libraries are consistent in the labeling and iconography.

Designing location search becomes so much easier when all libraries refer to the place with all the computers as the same thing. Keep labels the same across the different locations. If you call it a “Computer Lab” at one location, resist the urge to call it the “Computer carrels” at another location. (This might mean some overall discussions within the libraries—nothing like a joint project to surface all the inconsistencies that might be confusing your audience.)

Controlled Vocabularies are your friend—both in labels and in iconography. Further, this consistency also helps your audience understand what’s available at a location (as presented on the location pages and search results) and even navigate to those destinations within the space.

Take the UCLA Library as an example. The UCLA Library used some custom made icons to designate various destinations in their libraries, creating consistency across the various locations, the main website, and the location sitelets. Once we started creating the Destinations for each location, we realized that not all Destinations had iconography, so our creative director spent some time expanding on their visual vocabulary. It was critical that everything used on the website feel like it could also be dropped onto library signage without appearing out of place.

Here you can see some of their signage and how iconography plays an important role in conveying what’s available at the destination.

Both the locations and destinations on the website use these same icons to communicate the available amenities.

Sidenote: Consistency can be useful when it’s helpful. But it can also get in the way of communicating important differences—whether those differences come from the brand or facility. Divergence can be a good thing. You just need to ensure that the divergence is meaningful and useful for your audience. Perhaps there is a difference in a Computer Lab (a place where students can use computers) and Computer Carrels (a place designed for laptop use -- no computers provided). However, subtle differences may not be important to people and calling attention to them may only serve to confuse them more.

Bonus Challenge - Who owns what

One last, very important aspect of any web project: who is responsible for editing and maintaining the content on the website. Even if you have a copywriter or two, you are still faced with the gargantuan task of maintaining a mountain of information. (And sadly, this is no exaggeration.) No matter your process for editing and creating content, you need to identify the owner of each content and what their responsibilities entail. (Are they editing the content as needed? Are they filing change requests to the copywriter?)

In Conclusion...

Reconciling the needs of these varied and diverse stakeholders, libraries, locations, and library users can be a daunting task.  Hopefully, if you take the time to address the challenges in this series your end result will meet the needs of the most important audience—as well as many of the needs of your secondary and tertiary audiences.  With such a large network of stakeholders and users, you won’t please everyone, but with good user research and usability testing, you’ll get a lot closer to that goal, and you’ll have a firm foundation for the choices you make.

Tags: Drupal Planet
Catégories: Elsewhere

Dirk Eddelbuettel: RProtoBuf 0.4.2

Planet Debian - ven, 12/12/2014 - 03:19

A new release 0.4.2 of RProtoBuf is now on CRAN. RProtoBuf provides R bindings for the Google Protocol Buffers ("Protobuf") data encoding library used and released by Google, and deployed as a language and operating-system agnostic protocol by numerous projects.

Murray and Jeroen did almost all of the heavy lifting. Many changes were triggered by two helpful referee reports, and we are slowly getting to the point where we will resubmit a much improved paper. Full details are below.

Changes in RProtoBuf version 0.4.2 (2014-12-10)
  • Address changes suggested by anonymous reviewers for our Journal of Statistical Software submission.

  • Make Descriptor and EnumDescriptor objects subsettable with "[[".

  • Add length() method for Descriptor objects.

  • Add names() method for Message, Descriptor, and EnumDescriptor objects.

  • Clarify order of returned list for descriptor objects in as.list documentation.

  • Correct the definition of as.list for EnumDescriptors to return a proper list instead of a named vector.

  • Update the default print methods to use cat() with fill=TRUE instead of show() to eliminate the confusing [1] since the classes in RProtoBuf are not vectorized.

  • Add support for serializing function, language, and environment objects by falling back to R's native serialization with serialize_pb and unserialize_pb to make it easy to serialize into a Protocol Buffer all of the more than 100 datasets which come with R.

  • Use normalizePath instead of creating a temporary file with file.create when getting absolute path names.

  • Add unit tests for all of the above.

CRANberries also provides a diff to the previous release. RProtoBuf page which has a draft package vignette, a a 'quick' overview vignette, and a unit test summary vignette. Questions, comments etc should go to the GitHub issue tracker off the GitHub repo.

This post by Dirk Eddelbuettel originated on his Thinking inside the box blog. Please report excessive re-aggregation in third-party for-profit settings.

Catégories: Elsewhere

Propeople Blog: Drupal UX Improvements: When Node Forms are a Nuisance

Planet Drupal - ven, 12/12/2014 - 00:16

Node forms can be big. With field collections, reference fields, tags, taxonomies, location fields, and others, node forms can actually be really big. This can make an editor’s experience so frustrating that it’s a surprise she doesn’t have a heart attack when she sees how much data she needs to enter in order to save the form.

Sound familiar? Well, in this article we will share some tips and tricks that we use to simplify editors’ lives and to make the Drupal editing experience more user-friendly.

Split a form into tabs

If you have too many fields on one screen, it’s nearly impossible for an editor to remember what he entered in the beginning by the time he’s reached the end of the page. The answer to this quandary is simple: it’s time to split up the form.

It is possible to use different criteria to split forms into more manageable sections, or tabs. The criteria you’ll use will depend on the type of form and its intended purpose. Forms can be split up by field types, required vs. optional fields, priority rank, more vs. less frequently used; the list goes on. To create an even better user experience, ask the editors themselves about how they’d like forms to be organized. If they have been using a particular form for a while, it’s likely they’ll have plenty of valuable feedback regarding the best way to make the forms more intuitive and improve the efficiency of their workflow.

From a technical perspective, there are multiple ways to achieve more manageable forms. The one we use most frequently utilizes vertical tabs. An example of this is shown in the screenshot below.

 

Vertical tabs help editors to concentrate on one thing at a time and improves the navigation experience when working with especially large forms. A good rule of thumb is to divide the form into chunks that won’t require users to scroll through more than 1 to 1.5 pages to complete all the elements on any given section.

In addition to vertical tabs, you have the option to set up horizontal ones. This can easily be achieved with the Field Group module.

Split a form into columns

Some editors set up their workstations to use fairly wide screens. In this case, another practical approach is to have multiple columns. This solution can be used to nicely group fields together so they can be viewed side by side.

Drupal's Panels module make it easy to configure forms that use columns. Simply set up the layout for a node’s edit form and arrange the fields however you like.

Warn editors about unsaved changes

If you use JIRA or Google Docs, you’ve probably seen a warning message like the one shown below.

 

For a busy editor juggling multiple tasks, this friendly little pop-up can be a lifesaver. And of course… there’s a module for that.

Allow us to introduce Node Edit Protection. It helps editors to remember to save their changes before navigating away from a form. This becomes especially handy if you’ve split your forms into multiple tabs, as editors may think that simply switching to another tab automatically saves their changes.

Taxonomy tag widgets

You won’t hear any complaints from us about the standard autocomplete feature and the way it enables editors to quickly select appropriate tags. There are multiple widgets, however, that put the icing on the autocomplete cake. One of these that we particularly like is Chosen.


 

Another good one is Autocomplete Deluxe.

 

Links

Sometimes editors need some help building links in WYSIWYG or when using link fields. This is especially true when editors need to search for and quickly locate the content or URL they want to reference. Enter the Linkit module, which acts as a link-specific autocomplete function.

 

With the Linkit Picker module, we can even have a custom view to search for the content we would like to link to. This allows us to configure additional filters to help editors find content more effectively.

 

References

If you are using reference fields, there is a nifty module called References Dialog. This module allows editors to create a referenced entity while working within a node using a dialog box.

 

This comes in very handy, especially when your referenced entities include only a handful of fields and can fit comfortably into the dialog pop-up.

May we suggest...

For more great ideas that will have editors singing your praises, check out this presentation from DrupalCon Amsterdam 2014 about building a better backend, as well as our colleague Boyan Borisov’s presentation about improving Drupal's editorial experience.

Interested in learning even more about how Propeople can create a Drupal platform with user-friendly backend functionality for you? Don't hesitate to contact us.

Tags: DrupalUXcontent managementService category: TechnologyCheck this option to include this post in Planet Drupal aggregator: planetTopics: Tech & Development
Catégories: Elsewhere

Drupal core announcements: All TestBase derived tests now enforce strict configuration schema adherence by default

Planet Drupal - jeu, 11/12/2014 - 22:03

Configuration schema was originally introduced to help describe configuration for translations. Then it expanded considerably and is now used to export configuration entities automatically for example (unless you want to write code to manually define what to export). Configuration schema is also used to automatically typecast values to their expected types. This ensures that although PHP and web forms in general favour strings over all other types, the right types are used when saving configuration. That is important so when deploying configuration, only actual changes will show up in the difference, no random type changes. Schema enforces certain rules and best practices of configuration on its users, for example that each piece in the active configuration should have an owner. Finally configuration schema based configuration validation helps find several types of bugs in code that is otherwise not or incorrectly tested.

Therefore after a month+ of work to make all core tests pass strict configuration schema checking, we are making TestBase default to strictly check all configuration against configuration schemas. There are only a few tests exempt from this in the testing of the configuration system itself. This affects all contributed module developers writing TestBase (WebTestBase, KernelTestBase, etc.) extending tests. This may result in new test failures which indicate either issues in your schema, your configuration, your tests, migrations, etc. Either way it indicates that in some cases unexpected data structures are generated.

Read more in the change notice.

Catégories: Elsewhere

Gregor Herrmann: GDAC 2014/11

Planet Debian - jeu, 11/12/2014 - 21:45

is enthusiasm contagious? I think so. a recent example: another advent posting. – ¡gracias!

this posting is part of GDAC (gregoa's debian advent calendar), a project to show the bright side of debian & why it's fun for me to contribute.

Catégories: Elsewhere

Mediacurrent: Upcoming Webinar: Migrating The Weather Channel Onto Drupal

Planet Drupal - jeu, 11/12/2014 - 17:39

The Weather Channel (TWC) has one of the most trafficked websites in the world, which makes it one of the largest Drupal sites in the world.

Catégories: Elsewhere

Blink Reaction: Creating Custom Search Pages with Search404 and Apache Solr Search

Planet Drupal - jeu, 11/12/2014 - 17:19

Imagine somewhere deep in your site that you have a page with the alias:

/how-to-build-drupal-site.

Now, let’s imagine this page is not a link in your site’s menu. Your visitor remembers that they have seen this page on your site and starts typing in the address line:

Catégories: Elsewhere

Acquia: 5 PHP Components every Drupal 8 Developer should know: Part 2 -- Guzzle

Planet Drupal - jeu, 11/12/2014 - 16:15

In our previous blog post, we took a look at Composer, a PHP-based class autoloader and dependency management tool, and used it to begin managing some dependencies and downloaded Guzzle. Guzzle is a PHP-based HTTP client library that greatly simplifies the process of consuming RESTful web services. In this blog, we’re going to explore some of Guzzle’s basic abilities, and use it to begin building a simple SDK of sorts.

Catégories: Elsewhere

Enrico Zini: ssl-protection

Planet Debian - jeu, 11/12/2014 - 15:35
SSL "protection"

In my experience with my VPS, setting up pretty much any service exposed to the internet, even a simple thing to put a calendar in my phone requires an SSL certificate, which costs money, which needs to be given to some corporation or another.

When the only way to get protection from a threat is to give money to some big fish, I feel like I'm being forced to pay protection money.

I look forward to this.

Catégories: Elsewhere

Code Karate: Drupal 7 Sweaver Module: Change your theme style with no CSS code

Planet Drupal - jeu, 11/12/2014 - 14:49
Episode Number: 185

The Drupal 7 Sweaver module makes it easy to change the style of your Drupal theme without having to write any CSS code or dig through any template files. The Sweaver module provides a simple to use designer toolbar that sits at the bottom of the page and allows you to instantly change the look of your Drupal theme.

Tags: DrupalDrupal 7Theme DevelopmentDrupal PlanetUI/DesignCSS
Catégories: Elsewhere

Code Karate: Smart Paging: How to display a node on multiple pages

Planet Drupal - jeu, 11/12/2014 - 14:18
Episode Number: 184

The Smart Paging module is one of those "nice to have" modules. This module allows the ability to break content on a particular node into multiple pages. It is important to remember though that this doesn't mean you have to create multiple nodes or Drupal pages. This module works off of the same node. Neat!

Tags: DrupalContent TypesDrupal 7Site BuildingDrupal Planet
Catégories: Elsewhere

Rapha&#235;l Hertzog: Freexian’s fourth report about Debian Long Term Support

Planet Debian - jeu, 11/12/2014 - 12:32

Like each month, here comes a report about the work of paid contributors to Debian LTS.

Individual reports

In November 42.5 work hours have been equally split among 3 paid contributors. Their reports are available:

  • Thorsten Alteholz did his share as usual.
  • Raphaël Hertzog worked 18 hours (catching up the remaining 4 hours of October).
  • Holger Levsen did his share but did not manage to catch up with the backlog of the previous months. As such, those unused work hours have been redispatched among other contributors for the month of December.
New paid contributors

Last month we mentioned the possibility to recruit more paid contributors to better share the work load and this has already happened: Ben Hutchings and Mike Gabriel join the list of paid contributors.

Ben, as a kernel maintainer, will obviously take care of releasing Linux security updates. We are glad to have him on board because backporting kernel fixes really need some skills that nobody else had within the team of paid contributors.

Evolution of the situation

Compared to last month, the number of paid work hours has almost not increased (we are at 45.7 hours per month) but we are in the process of adding a few more sponsors: Roche Diagnostics International AG, Misal-System, Bitfolk LTD. And we are still in contact with a couple of other companies which have announced their willingness to contribute but which are waiting the new fiscal year.

But even with those new sponsors, we still have some way to go to reach our minimal goal of funding the equivalent of a half-time position. So consider asking your company representative to join this project!

In terms of security updates waiting to be handled, the situation looks better than last month: the dla-needed.txt file lists 27 packages awaiting an update (6 less than last month), the list of open vulnerabilities in Squeeze shows about 58 affected packages in total. Like last month, we’re a bit behind in terms of CVE triaging and there are still many packages using SSLv3 where we have no clear plan (in response to the POODLE issues).

The good side is that even though the kernel update spent a large chunk of time to Holger and Raphaël, we still managed to further reduce the backlog of security issues.

Thanks to our sponsors

No comment | Liked this article? Click here. | My blog is Flattr-enabled.

Catégories: Elsewhere

Steve Kemp: An anniversary and a retirement

Planet Debian - jeu, 11/12/2014 - 11:56

On this day last year I we got married.

This morning my wife cooked me breakfast in bed for the second time in her life, the first being this time last year. In thanks I will cook a three course meal this evening.

 

In unrelated news the BlogSpam service will be retiring the XML/RPC API come 1st January 2015.

This means that any/all plugins which have not been updated to use the JSON API will start to fail.

Fingers crossed nobody will hate me too much..

Catégories: Elsewhere

Dirk Eddelbuettel: digest 0.6.6 (and 0.6.5)

Planet Debian - jeu, 11/12/2014 - 02:27

A new release 0.6.6 of the digest package is now on CRAN and in Debian.

This release brings the xxHash non-cryptographic hash function by Yann Collet, thanks to several pull requests by Jim Hester. After the upload of version 0.6.5 we uncovered another lovely non-standardness of Windoze: you cannot format unsigned long long via printf() format strings. Great. Luckily Jim found a quick (and portable) fix via the inttypes.h header, and that went into the 0.6.6 release.

The release also contains an earlier extension for hmac() to also cover crc32 hashes, kindly provided by Suchen Jin.

I also made a number of small internal changes such as

  • switching (compiled) function registration to package load via a the useDynLib() declaration in NAMESPACE,
  • (finally!!) formating code to proper four-space indentation,
  • adding some documentation around Jim's pull request, and
  • adding a few GPL copyright headers.

CRANberries provides the usual summary of changes to the previous version.

This post by Dirk Eddelbuettel originated on his Thinking inside the box blog. Please report excessive re-aggregation in third-party for-profit settings.

Catégories: Elsewhere

Dirk Eddelbuettel: RcppRedis 0.1.3

Planet Debian - jeu, 11/12/2014 - 01:59

A very minor bugfix release of RcppRedis is now on CRAN. The zcount function now returns the correct type.

Changes in version 0.1.3 (2014-12-10)
  • Bug fix setting correct return type of zcount

Courtesy of CRANberries, there is also a diffstat report for the most recent release. More information is on the RcppRedis page.

This post by Dirk Eddelbuettel originated on his Thinking inside the box blog. Please report excessive re-aggregation in third-party for-profit settings.

Catégories: Elsewhere

Pages

Subscribe to jfhovinne agrégateur