Newsfeeds

The RPGnet Interview: Aaron A. Reed, Archives of the Sky

RPGNet - 24 May 2018 - 12:00am
A talk about story game design and Archives of the Sky.
Categories: Game Theory & Design

myDropWizard.com: Drupal 6 in the year 2020 (and with PHP 7 support!)

Planet Drupal - 23 May 2018 - 11:24pm

When we originally announced that we'd be providing Drupal 6 Long-Term Support, we committed to supporting our customers until at least February 2017.

Each year in the spring, we've taken a look at the state of Drupal 6 and decide whether we'll extend support for another year, and if we need to make any changes to our offering. Here's the articles from 2016 and 2017, where we announced support until at least February 2019.

Today, I'm happy to announce that we'll be extending our Drupal 6 Long-Term Support until at least February 2020!

While I'm sure there will come a time, when it no longer makes business sense to pour resources into Drupal 6 for the few remaining sites, however, it's already clear to us that there's enough demand to one more year.

However, this time is a little different because PHP 5.6 will reach the end of its security support in December 2018 (8 months from now).

We can't responsibly provide Long-Term Support for Drupal 6, if there isn't a PHP version that you can securely run it on.

So, this year we're making some bigger changes to the program and price and to Drupal 6 itself!

Read on to find out more!

Categories: Drupal

Find term

New Drupal Modules - 23 May 2018 - 9:50pm

This module will provide a search form inside terms overview pages to help admin users to find taxonomy term by term name.

(Find taxonomy term by term name at terms overview page.)

Categories: Drupal

Sector blog

New Drupal Modules - 23 May 2018 - 7:33pm

Sector Blog offers a simple and easy to use blog to publish updates, engage with your audience, or collaborate across teams and locations. Included is everything you'll need to get going - a Blog post content type, automated lists and filtered archives, as well as comments and a Blog editor user role.

Sector Blog is an optional Sector Add-on. The Sector Blog components and configuration make it easy to get started, and the sample content make it easy to grasp the main features.

Categories: Drupal

Battlefront Posts Free Nations Book Spotlight

Tabletop Gaming News - 23 May 2018 - 3:00pm
We’re just a couple weekends away from the release of Free Nations, the newest book for Team Yankee from Battlefront. But what’s coming in the new release? What new forces will be heading to the fields of Europe? How will they stack up against what’s already available? Well, Battlefront has posted up a detailed book […]
Categories: Game Theory & Design

Bitcon Cards: Lose All Your Money Card Game Up On Kickstarter

Tabletop Gaming News - 23 May 2018 - 2:00pm
Cryptocurrency. Honestly, all I know about it I learned from John Oliver. So I’m not really one to try and discuss it. However, after playing Bitcon Cards: Lose All Your Money, we all might just be experts in how they work. The game is a new card game up on Kickstarter now. Originally created as […]
Categories: Game Theory & Design

Wargaming Seattle is shutting down

Social/Online Games - Gamasutra - 23 May 2018 - 1:58pm

Update This is a big deal given that Wargaming Seattle is the Redmond-based studio formerly known as Gas Powered Games, which was founded in 1998 by Chris Taylor and other former Cavedog devs. ...

Categories: Game Theory & Design

Loot N Shoot Reloaded Up On Kickstarter

Tabletop Gaming News - 23 May 2018 - 1:00pm
How many of us haven’t, at some point in time, shot a rubber band across the room? Maybe you were aiming for something (or someone), or just having fun, but we all know someone who’s really good at it. If that’s you, then you might have an innate advantage in Loot N Shoot, a dexterity […]
Categories: Game Theory & Design

Don't Miss: How RuneScape maintains its prolific update schedule

Social/Online Games - Gamasutra - 23 May 2018 - 12:34pm

In this 2016 GDC session, Jagex's Conor Crowley covers how the development team for RuneScape moved from an established development process to multiple agile cross-disciplined teams without missing an update. ...

Categories: Game Theory & Design

Jagex shutting down RuneScape Classic after 17 years

Social/Online Games - Gamasutra - 23 May 2018 - 12:12pm

RuneScape developer Jagex has announced that it will shut down RuneScape Classic on August 6, 2018, ending support for the early online game 17 years after its first launch. ...

Categories: Game Theory & Design

Interbellum RPG Up On Kickstarter

Tabletop Gaming News - 23 May 2018 - 12:00pm
We’ve got lots of games out there about WWII and subsequently, there’s also a good number of Weird-War-II stuff. What I’d love to see more of is WWI games, and then, Weird-War-I stuff. *looks at Interbellum* Oh, hey there! The game is an RPG that brings in magic and other supernatural elements to the conflicts […]
Categories: Game Theory & Design

Drupal.org blog: Drupal.org's GDPR compliance statement

Planet Drupal - 23 May 2018 - 11:50am

Our global community includes many EU citizens and residents of the EEA, and we have taken steps to comply with the GDPR which takes effect on May 25, 2018.

Your rights under this law and how Drupal.org complies with GDPR

We've updated our Terms of Service, Privacy Policy, Git Contributor Agreement, and Digital Advertising Policy based on the requirements of the EU General Data Protection Regulation. We've also begun a campaign to reconfirm your consent to our marketing messages.

For easy and clear access to the changes: 

Human Readable Summary

Disclaimer: This summary is not itself a part of the Terms of Service, Privacy Policy, Git Contributor Agreement, or Digital Advertising Policy, and is not a legal document. It is simply a handy reference for understanding privacy rights and regulations. Think of it as the user-friendly interface to the legal language.

In plain language, regulations such as GDPR define the following roles, rights, and responsibilities:

  • Data Subject - this is you, the end user.
  • Data Controller - this is us, the Drupal Association as the owners and operators of Drupal.org and its sub-sites.
  • Data Processor - any other organization that processes personal data on behalf of the Data Controller.
Rights of the Data Subject
  • Right to be Informed - A data subject has the right to know whether personal information is being processed; where; and for what purpose.
     
  • Right to Access - A data subject has a right to access the information about them that is stored by the Data Controller.
     
  • Right to Rectification - A data subject has the right to correct any errors in the data about them. This can be done by editing your user account, or contacting the Drupal Association directly.
     
  • Right to Restrict Processing - A data subject has the right to request that data not be processed, and yet also not be deleted by the Data Controller.
     
  • Right to Object - A data subject has the right to opt out of marketing, processing based on legitimate interest, or processing for research or statistical purposes.
     
  • Right to be Forgotten - Also known as the right to revoke consent, the right to be forgotten states that a data subject has the right to request erasure of data, the cessation of processing by the controller, and halting processing of the data by third party processors.

    The conditions for this, as outlined in article 17, include the data no longer being relevant to original purposes for processing, or a data subjects withdrawing consent.

    It should also be noted that this right requires controllers to compare the subjects' rights to "the public interest in the availability of the data" when considering such requests.

  • Data Portability - A data subject has the right to receive a copy of their data in a 'commonly used and machine readable format.'

    This information is outlined in the sections below titled "Your Choices About Use and Disclosure of Your Information" and "Accessing and Correcting Your Information".

Responsibilities of the Data Controller and Data Processors
  • Privacy by Design - 'The controller shall..implement appropriate technical and organisational measures..in an effective way.. in order to meet the requirements of this Regulation and protect the rights of data subjects'. Article 23 of the GDPR calls for controllers to hold and process only the data absolutely necessary for the completion of its duties, as well as limit the access to personal data to those who need it to carry out these duties.
     
  • Breach Notification - The Data Controller must notify the appropriate data processing authority and any affected end user of any breach that might result in 'risk to the rights and freedoms of individuals' within 72 hours of becoming aware of the breach.

    A Data Processor must notify the Data Controller of any breach 'without undue delay.'

  • Data protection officer - A Data Controller or Processor must appoint a Data Protection Officer when: a Data Controller represents a public authority; or the core operations of the Controller require regular and systematic monitoring of Subjects on a large scale; or when the Controller's core operations depend on processing a large scale of special categories of data (including but not limited to health data, criminal conviction information, etc).
     

    The Drupal Association's core operations do not require the Association to establish a Data Protection Officer.

We take privacy and security very seriously, as all Drupal professionals do! We will continue analyzing the legal landscape and collecting feedback for future revisions.

If you have any questions or concerns about our GDPR compliance, or if you want to point out a mistake or provide a suggestion for the Terms of Service, Privacy Policy, Git Contributor Agreement, or Digital Advertising policy, you can send an email to help@drupal.org.

Categories: Drupal

Midweek Snippets

Tabletop Gaming News - 23 May 2018 - 11:00am
Halfway there, everyone. We’re halfway there. The weekend is making its way inexorably towards us. And it’s a 3-day weekend, too. It’s looking like I’ll be getting in some Guild Ball on Sunday, along with some grilling. So that’s gonna be fun. Whatever you might have planned, be sure you’re not famished by snacking on […]
Categories: Game Theory & Design

Cookiebot integration

New Drupal Modules - 23 May 2018 - 10:50am

WIP

Categories: Drupal

Ostfront Releases Air Strike Air Combat Game

Tabletop Gaming News - 23 May 2018 - 10:00am
Air combat games can be pretty complex. There’s all sorts of things that can be thrown in, and as such, they can tend to be hard for new players. Air Strike does away with all that. It’s so simple, the whole family can enjoy it. Hop into the cockpit of your favorite fighter aircraft and […]
Categories: Game Theory & Design

Field Group Settings

New Drupal Modules - 23 May 2018 - 9:27am

A field group formatter to hide settings unobtrusively on the form. Any fields within this group will hide in a panel that is toggled by a button. This button (a gear icon) will float to the right side of the form.

Categories: Drupal

WYSIWYGames Running Z First Impact Kickstarter

Tabletop Gaming News - 23 May 2018 - 9:00am
I took French in high school (because I just knew that I was going to play hockey and I wanted to be able to talk with my French-Canadian teammates). However, as you can tell, I did not end up being drafted for the NHL, and so my French skills are lacking. As such, if I […]
Categories: Game Theory & Design

Lullabot: Decoupled Drupal Hard Problems: Schemas

Planet Drupal - 23 May 2018 - 8:59am

The Schemata module is our best approach so far in order to provide schemas for our API resources. Unfortunately, this solution is often not good enough. That is because the serialization component in Drupal is so flexible that we can’t anticipate the final form our API responses will take, meaning the schema that our consumers depend on might be inaccurate. How can we improve this situation?

This article is part of the Decoupled hard problems series. In past articles, we talked about request aggregation solutions for performance reasons, and how to leverage image styles in decoupled architectures.

TL;DR
  • Schemas are key for an API's self-generated documentation
  • Schemas are key for the maintainability of the consumer’s data model.
  • Schemas are generated from Typed Data definitions using the Schemata module. They are expressed in the JSON Schema format.
  • Schemas are statically generated but normalizers are determined at runtime.
Why Do We Need Schemas?

A database schema is a description of the data a particular table can hold. Similarly, an API resource schema is a description of the data a particular resource can hold. In other words, a schema describes the shape of a resource and the datatype of each particular property.

Consumers of data need schemas in order to set their expectations. For instance, the schema tells the consumer that the body property is a JSON object that contains a value that is a string. A schema also tells us that the mail property in the user resource is a string in the e-mail format. This knowledge empowers consumers to add client-side form validation for the mail property. In general, a schema will help consumers to have a prior understanding of the data they will be fetching from the API, and what data objects they can write to the API.

We are using the resource schemas in the Docson and Open API to generate automatic documentation. When we enable JSON API and  Open API you get a fully functional and accurately documented HTTP API for your data model. Whenever we make changes to a content type, that will be reflected in the HTTP API and the documentation automatically. All thanks to the schemas.

A consumer could fetch the schemas for all the resources it needs at compile time or fetch them once and cache them for a long time. With that information, the consumer can generate its models automatically without developer intervention. That means that with a single implementation once, all of our consumers’ models are done forever. Probably, there is a library for our consumer’s framework that does this already.

More interestingly, since our schema comes with type information our schemas can be type safe. That is important to many languages like Swift, Java, TypeScript, Flow, Elm, etc. Moreover, if the model in the consumer is auto-generated from the schema (one model per resource) then minor updates to the resource are automatically reflected in the model. We can start to use the new model properties in Angular, iOS, Android, etc.

In summary, having schemas for our resources is a huge improvement for the developer experience. This is because they provide auto-generated documentation of the API and auto-generated models for the consumer application.

How Are We Generating Schemas In Drupal?

One of Drupal 8's API improvements was the introduction of the Typed Data API. We use this API to declare the data types for a particular content structure. For instance, there is a data type for a Timestamp that extends an Integer. The Entity and Field APIs combine these into more complex structures, like a Node.

JSON API and REST in core can expose entity types as resources out of the box. When these modules expose an entity type they do it based on typed data and field API. Since the process to expose entities is known, we can anticipate schemas for those resources.

In fact, assuming resources are a serialization of field API and typed data is the only thing we can do. The base for JSON API and REST in core is Symfony's serialization component. This component is broken into normalizers, as explained in my previous series. These normalizers transform Drupal's inner data structures into other simpler structures. After this transformation, all knowledge of the data type, or structure is lost. This happens because the normalizer classes do not return the new types and new shapes the typed data has been transformed into. This loss of information is where the big problem lies with the current state of schemas.

The Schemata module provides schemas for JSON API and core REST. It does it by serializing the entity and typed data. It is only able to do this because it knows about the implementation details of these two modules. It knows that the nid property is an integer and it has to be nested under data.attributes in JSON API, but not for core REST. If we were to support another format in Schemata we would need to add an ad-hoc implementation for it.

The big problem is that schemas are static information. That means that they can't change during the execution of the program. However, the serialization process (which transforms the Drupal entities into JSON objects) is a runtime operation. It is possible to write a normalizer that turns the number four into 4 or "four" depending if the date of execution ends in an even minute or not. Even though this example is bizarre, it shows that determining the schema upfront without other considerations can lead to errors. Unfortunately, we can’t assume anything about the data after its serialized.

We can either make normalization less flexible—forcing data types to stay true to the pre-generated schemas—or we can allow the schemas to change during runtime. The second option clearly defeats the purpose of setting expectations, because it would allow a resource to potentially differ from the original data type specified by the schema.

The GraphQL community is opinionated on this and drives the web service from their schema. Thus, they ensure that the web service and schema are always in sync.

How Do We Go Forward From Here

Happily, we are already trying to come up with a better way to normalize our data and infer the schema transformations along the way. Nevertheless, whenever a normalizer is injected by a third party contrib module or because of improved normalizations with backward compatibility the Schemata module cannot anticipate it. Schemata will potentially provide the wrong schema in those scenarios. If we are to base the consumer models on our schemas, then they need to be reliable. At the moment they are reliable in JSON API, but only at the cost of losing flexibility with third-party normalizers.

One of the attempts to support data transformations and the impact they have on the schemas are Field Enhancers in JSON API Extras. They represent simple transformations via plugins. Each plugin defines how the data is transformed, and how the schema is affected. This happens in both directions, when the data goes out and when the consumers write back to the API and the transformation needs to be reversed. Whenever we need a custom transformation for a field, we can write a field enhancer instead of a normalizer. That way schemas will remain correct even if the data change implies a change in the schema.

undefined

We are very close to being able to validate responses in JSON API against schemas when Schemata is present. It will only happen in development environments (where PHP’s asserts are enabled). Site owners will be able to validate that schemas are correct for their site, with all their custom normalizers. That way, when a site owner builds an API or makes changes they'll be able to validate the normalized resource against the purported schema. If there is any misalignment, a log message will be recorded.

Ideally, we want the certainty that schemas are correct all the time. While the community agrees on the best solution, we have these intermediate measures to have reasonable certainty that your schemas are in sync with your responses.

Join the discussion in the #contenta Slack channel or come to the next API-First Meeting and show your interest there!

Note: This article was originally published on November 3, 2017. Following DrupalCon Nashville, we are republishing (with updates) some of our key articles on decoupled or "headless" Drupal as the community as a whole continues to explore this approach further. Comments from the original will appear unmodified.

Hero photo by Oliver Thomas Klein on Unsplash.

Categories: Drupal

Chromatic: DrupalCon Nashville Recap

Planet Drupal - 23 May 2018 - 8:56am

It’s hard to believe DrupalCon Nashville was over a month ago! We have been busy here at Chromatic ever since, but we wanted to give a recap of the conference from our point of view.

Categories: Drupal

Late Pledges Open For The Reckoners

Tabletop Gaming News - 23 May 2018 - 8:00am
Kickstarters come and go. It’s easy to miss one in all the shuffle. Thankfully, there’s usually Late Pledge opportunities. However, those don’t last forever, either. So, if you missed out on getting The Reckoners as part of the Kickstarter, don’t miss out on also getting it during the Late Pledge time. From the website: Games […]
Categories: Game Theory & Design

Pages

Subscribe to As If Productions aggregator