The first couple of months of a Drupal 8 project usually set the tone for the entire development process. Making bad decisions (or creating bad habits) in the first phase of a project should be avoided at all costs. Using his almost 20 years(!) of web development experience as a resource, Mike Anello (@ultimike) provides 11 practical recommendations to help ensure your project gets started (and launches) on the right foot. Mike’s tips are accessible and suitable for developers, designers, and project managers.
We recently finished a project of converting our intranet landing pages to a unified single landing page for the entire company (rollout of all hospitals is pending). This project has helped us in becoming a true Scrum team and has made its impact beyond the project itself. The big deal is that the rituals, which sounded unnecessary and time-consuming, have become our habits. Instead of "questioning" these rituals, we "expect" them. That's where the mindset changes. Coming from a traditional project management background, it was not easy for us to adapt to the new Agile/Scrum methods and processes. We were used to doing the reverse engineering of the project milestones based on a given due date and I have successfully completed many projects using that methodology.
Ally and I would like to share our journey with others. The takeaway from this event will be multifold - 1) ScrumMasters and project managers will get few key elements which helped us transforming a conventional team into a Scrum team, 2) Managers and team leaders will get few key elements on how to support their Scrum team and 3) programmers will learn how these changes will impact them and how they can support the transformation process.
This session will
- Talk about the benefits and risks of using Behat Tests in your day to day Drupal development practices.
- Walk through setting up Behat Tests, from scratch, as a live demo. A breakdown of how to really get started
- What it means to embrace true Test Driven Development.
- Examples of thorough test suites for complex web applications built in Drupal.
- Demonstration of the new DevShop Behat Extension which simplifies setup and adds helpful steps, and the DevShop Composer Template which includes it for a working, testable, composer based Drupal build out of the box.
- How to create Pull-Request generated environments and run Behat tests automatically using open source DevShop.
A variations of this session was given at Cornell DrupalCamp, it can be watched here: https://camp.drupal.cornell.edu/sessions/get-behat-tests-bandwagon
With the recent set of AWS commercials airing during popular sporting events and other pop-culture TV shows it is no surprise that many individuals equate "the cloud" to AWS. All-told, Amazon Web Services has taken control of the online "cloud" marketplace and released hundreds of different products from virtual servers (EC2) to multiple ways to run containers (ECS, EKS) to a variety of different storage techniques.
For folks just getting started with trying to host their Drupal website, it can be overwhelming with the number of offerings and quickly cause developers to go running to the trusty "virtual server" that they install LAMP on and call it a day. But that isn't the best option for hosting your Drupal site on AWS. Join us as AWS Certified Solutions Architect Brian Thompson goes through the multiple ways of hosting your Drupal website in "the cloud" including servers, databases, storage, scaling, and tips/tricks along the way. You'll walk away from the talk with a better understanding of how AWS can work for you and you can get the most bang for your buck (or your client's buck) while making sure you don't get phone calls on New Years Eve about a site being down.
Whether building a new skill or rebounding after one of life's inevitable setbacks, having the right mindset can save you time and headaches.
Told through the lens of the speaker’s errant Googlings, this session will take participants on a journey from music teacher to web developer, all the while examining the different types of learning that occurred along the way. This session will delve into theories about learning, techniques to improve information retention and problem solving, and how to shift your perspective to learn from even the bleakest situations.
Embark on a harrowing adventure through a stranger's search history, and emerge on the other side with:
- A greater understanding of the learning process
- Practical strategies that you can utilize in your own learning
- A new perspective on the value of discomfort and failure.
Drupal traditionally handles both content management and front-end rendering as part of its core functionality. Decoupled Drupal, in contrast, uses Drupal only for the content management, and does front-end rendering completely outside the Drupal ecosystem.
You can, and it’s called progressive decoupling -- leveraging parts of Drupal's rendering engine alongside your decoupled applications.
Attendees will leave with an understanding of the following:
- The pros and cons of progressively decoupling your site
- Leveraging progressively decoupled blocks in Drupal regions
- Configuration management between blocks and ReactJS applications
- xposing Drupal data to the ReactJS app using RESTful means.
With these tools, intermediate Drupal developers can combine the takeaways from this session into a fantastic experience for both end users and site developers.
Your ready to make that new release. You've tested it all in Docker locally, so you hit that commit button and push it all to production, confident that your CI will deploy it perfectly every time. Then, disaster strikes: A minor difference between prod and your local brings your site down. If only you could use the same containers locally as in production!
Now you can, with Kubernetes.
This session introduces Kubernetes (k8s), an open source container orchestrator that provides a production-tested cluster to run your Drupal site. This session will walk you through how to build your own k8s cluster, how to update your containers to run securely with Secrets and ConfigMaps, and how to automate deployment to run your containers from "Initial Commit" to 1.0.
Let's finally have a walk-through that gets us to deploy. So many articles, tutorials, and other resources seem to bring us right up to the cusp of deployment, but, regretibly, anticlimatically, never bring you to grasp that last step.
Watch over my shoulder (as it were) while we demonstrate at least 2 deployment strategies. We'll use Gitlab and Laravel's Envoy--an SSH task runner that makes life amazingly simple.
How many times have you ever heard? "Choose the right tool for the job" or "When all you have is a hammer, everything looks like a nail."
The Drupal community is embracing the "Get off the island" mantra. Modernizing Drupal was the goal of the latest Drupal 8 release, but technology moves faster than the awesome community could improve our beloved platform.
Gatsby is taking the world by storm and the JAMstack is here to stay. Come to this session, to learn what can we do to keep Drupal relevant and this new era.
During this session you will learn:
- The main differences between a "Traditional CMS" - "Headless CMS" - "Static Site".
- The importance of decoupling the "Content Management GUI" from the "Production Environment".
- The benefits of using a modern JAMstack to serve your site.
- How can you improve the UX providing a GUI when using a Git-based CMS.
- How to use Drupal to provide a GUI and content for a Git-based/API-driven CMS.
- Which modules you need on your Drupal site to behave as Headless CMS and provide a better integration with GatsbyJS.
- Which GatsbyJS plugins are required to a better integration with a Drupal data source.
- How to properly configure GatsbyJS plugins to take advantage of markdown preprocessing.
- How to deploy your site to a CDN.
- How to triggering automatic builds based on content updates.
With Drupal 8.6 released we got into a new era of flexible layouts and different creative solutions that are now available at site builders fingertips.
Do you want to learn how to build great flexible framework that opens a completely new level of editorial and publishing experience right out of Drupal core? Have you been wondering what contrib solution to use and when? Join me on a journey of advanced site building: from layout API deep in core ocean to the peaks of mountains of contrib modules such as paragraphs and bricks.
“We are currently looking for the next Rockstars to join our stellar team! All employees must have killer work ethic and offer fanatical customer service.”
Job postings, among so many other things, can be unintentionally exclusive.
Inclusivity is at the heart of an effective content strategy. Accessible code may be imperative for inclusion, but all the code in the world doesn’t do any good if the content is not meaningful to our readers.
In this session, we’ll go over what we can do as content authors to ensure our readers feel that we are speaking with them, not at them. We’ll look beyond the semantic markup and structured content to see the strategic value of inclusive, well written content.
Discussion points will include:
- What makes content inclusive? Including: definitions, clarifications, and real-life examples
- Why is inclusive language important?
- How we can embrace accessibility for those with every sort of ability
- Why awareness and acceptance isn’t enough — how to shift to being more process oriented
DevPanel automates your AWS account. Develop, Deploy, Manage, and Scale Drupal. All point & click! All in your own account.
DevPanel sets up a highly-available auto-scaling cluster in your AWS account where you can create as many Drupal sites as you want, each with its own dev/test/live versions.
The cluster shrinks down to one or two servers at night when you don't have any traffic and can automatically grow to handle all the traffic for all your sites. This, itself, will save you a ton of money in hosting your sites. If you're OK using SPOT instances, then you can also save up to 90% on AWS standard compute rates too.
DevPanel is tightly integrated with AWS and uses Elastic Container Service (ECS) with Elastic File System (EFS), Relational Database Service (RDS) and Elastic Load Balancer (ELB) to build a solid micro-services based framework under your AWS account. All the scripts are Open Source and available under GPL on GitHub/devpanel.
Come see how you can start using DevPanel individually and with your teams.
From Multifield module to Field Collections and Paragraphs, the site-building tools at our disposal continue to mature. As one gains traction, its weaknesses begin to show and new solutions spring forth. And so it continues with the sunset of Paragraphs. This talk is for anyone who:
- Builds with Paragraphs on medium-to-large sites, or
- Leverages ECK to craft sub-entity solutions, or
- Implements content architecture at scale.
Following on from of japerry's timely talk about the woes of entity references, we'll review the problems with using Paragraphs on large Drupal installations. When are sub-entity solutions a good fit, and when aren't they?
I'll demonstrate how you—yes, YOU!—can easily create custom fields. And finally, we'll look at a solution for developers and site builders alike, resurrecting multifield functionality from the ashes of Drupal 7 into the "Rich Fields" module for Drupal 8 (forthcoming to contrib).
I recently had the opportunity to work in a really interesting Drupal 8 project with a short deadline. One of the requirements of the project was that the client needed to be able to have control over the look and feel of almost all the site.
We decided that we needed to go with paragraphs because it would give the client that flexibility and we wanted to give it a try to Pattern Lab so we included it into the project. We expected these two elements to play nice together; however, we were wrong: they play HELL NICE together.
During this session, we'll talk about the process of going from the design to a polished and flexible website mainly built with these two tools. We'll learn how to extract the components for paragraphs, how to create them in Pattern Lab and how to bring them together.
No prior knowledge of paragraphs or Pattern Lab is required because we'll cover the basics during the talk so that you can get the most out of it.
Designers and developers rejoice! The war is over - accessibility and style don't have to be at odds with each other anymore. In fact, accessibility can be a really beautiful thing.
Sometimes we get a design that looks like an accessibility impossibility. Don't worry! With a little bit of can-do attitude and a few simple coding techniques, we can get almost any design to cooperate with accessibility. Whether it's getting mega-menus to play nicely with the keyboard, adhering to a color palette with strict branding standards, or adding some interactive panache to your site that everybody can enjoy, there are a lot of ways to make accessibility work (and look great!) that you might not expect.
In this session, you'll learn how to:
- Understand and manage focus and active states to ensure that complicated elements work properly with the keyboard
- Mitigate accessibility issues with contrast ratios when color palettes are challenging
- Improve accessibility with interactive states that look stylish for everyone
With the rise of remote working, distributed teams and online collaboration the impact of good communication and healthy work (and online) spaces has become one of the most important factors in the success or failure of projects. Unfortunately we sometimes tend to underestimate our own roles in being a good and healthy team or community and don't always put in the work necessary to be successful in these areas.
This will be a session exploring what good leadership and teamwork consists of, what makes that possible and, more importantly, what to work on so we can be better leaders and teams ourselves.
The session will be mostly focused on the soft skills we may have but sometimes take for granted, forget to work on or simply don't master as much as we want to.
We will also discuss and break down specific, and sometimes difficult aspects we encounter when working with others.
Some tips and topics will include:
- tips on better communication
- dealing with difficult conversations, people and situations
- giving and receiving criticism well
- assumptions, intent, impact and biases we may not be aware of
Local Drupal development can be tricky, especially with so many tooling choices. Having an environment that works for you is important whether you're a developer, tester, designer, or any sort of stakeholder. In this session, we'll review a few of the tools available (there are 37+ for Drupal at last count), their features, and meet some of the folks who build and use them. They'll all be spending time at the "Genius Bar" if you have more in-depth questions or want to get started installing.
This will be a panel discussion. Possible topics:
- Drush and Drupal Console support
- Remote host support
- Pre-made configurations
- Custom configurations
- Integrations with other services
- On-going support
- PHP options
- Windows, MacOS, Linux support
- Integration with hosting platforms
We all know that your website’s performance is critical to the success of its mission. Conversion rates are proven to plummet if with every second of page load time.
What can we do about this? Why is the web still slow in 2018?
In this session, we’re going deep into modern web performance, and you will learn how to identify and fix performance bottlenecks in your website / webapp through topics such as:
- Web performance metrics you should be measuring and how. Which are the most important?
- How do I optimize my site for each of these web performance metrics
- How browsers render web pages, and how to use this knowledge to optimize the loading experience.
- What is the critical path? How do I account for this?
- Identifying, profiling, and optimizing for third party scripts.
From programming hippies to acquisitions and IPOs, Open Source companies have shown incredible financial returns in the past year. Open Source projects have literally changed the face of the web and created a unique space in the corporate world. In this talk, Jason Nickerson will showcase how Open Source Projects promote diversity and community while building a quality software platform for market success.
A job is essentially a contract between an employee and an employer, in which the employee sells time in exchange for money and other benefits. During the course of a job interview, the interviewer tends to ask all or most of the questions. Do you know what you are looking for in a potential employer?
Life is too short to spend your time working for an employer that doesn’t match your values and fit your needs. What might happen if we start evaluating employers as thoroughly as a big purchase, such as a home or car?
In this session, we will discuss how to evaluate your current employer and when it’s time to to fire your employer. We will also explore ways to spend your time wisely when looking for and interviewing with potential employers.
Topics that will be covered:
- Values Matching
- Ideal Work Environment
- Culture Fit
- Salary Negotiation
- How to Quit
Many people today find themselves learning about DevOps by first seeing one of its outcomes and learning about how that outcome came to be. Learning why something is considered to be a part of DevOps is not necessary to implement those pieces of it. However, knowing why something would be considered a part of DevOps, or even why a DevOps strategy is important, and for who, can mean the difference between following and leading in an industry.
In this talk, we will show, using intuition backed by empirical research, why DevOps is the most important technological strategy of our day. In doing so, attendees will gain the understanding necessary to gain buy-in for DevOps at their organization as well as how to know what might fit a DevOps strategy and what doesn't.
DevOps is a journey and how you do it matters too. Beyond the why of DevOps, this session expands further on how to go about choosing and implementing DevOps tools and practices. Attendees will gain insights into how they might start doing DevOps in their organization, or how to progress further if they've already gotten a start.
Finally, if you are able to implement a DevOps journey successfully, what will you see? In conclusion, this session will discuss various outcomes of successful DevOps implementations.
Overall, attendees of this session will leave with a foundational knowledge of DevOps that is sufficient to find their way to continued success in the field.
This talk will be dynamically tailored to Florida DrupalCamp based on survey results. Here is a version done for NED Camp: https://lastcallmedia.com/events/nedcamp-2018
What would you say is a common number of developers for a given Drupal website instance? Whatever you think that number is, there are stark differences working with a team of one or 30 developers on projects ranging from a few weeks to a few years. In this session, we will explore ways of working with many developers, stakeholders, and interested parties to reach project goals, including:
- Coding a platform versus a single website instance
- Moving from element-specific theming to global patterns
- Bringing new (to the project) developers into a team
- Peer-reviewing code and finding ways to minimize code conflicts
- Adopting new modules, coding standards, and deployments
At Mediacurrent we have embraced using the buzzword 'headless architecture' on a variety of projects. Our own website is using Drupal 8 but with a static site generator called Jekyll. We have also come to enjoy using Gatsby as more robust SSG, and are in the middle of converting the front end, without messing around with the content model of Drupal. It hasn't been all smooth sailing. This talk I will go over some of the pitfalls of this migration. Issues like the pains of using Gatsby when it wasn't really ready for Paragraphs or other entity types (it's much better now). Additionally I would like to show off our new React Components library, which is a conversion from the Pattern Lab Comonent Library to React.
This presentation is a high-level survey of emerging technologies that complement Drupal. Drupal can do a lot of things well, but, Drupal is also capable of working with best of breed tools thanks to its robust framework and vast set of contributed modules. We explore how this integration occurs for some promising technologies.
We have selected new and popular technologies that solve impactful problems commonly found when creating Drupal implementations. We describe why each technology should be considered. We share the separation of responsibilities between the technologies and Drupal with a focus on circumstances in which the technology should be adopted. And, finally, we present potential approaches for solutions that leverage both Drupal and the emerging technology in a complementary manner.
The emerging technologies we will explore are:
- Hubspot and marketing automation/CRM
- ElasticSearch and search/log management/visualization
- GraphQL/Schemata and decoupled web services
- Pattern Lab and design systems
- Gatsby.JS and static site generation
Attendees can expect to learn high-level capabilities of the emerging technologies and ideas on how to use them in concert with Drupal. This talk would be ideal for architects, business analysts, or systems integrators passionate about understanding Drupal’s place within a larger enterprise of tools.
With the continued rise of static site generators that can play nicely with Drupal it has never been easier to take advantage of the speed, security, and scalability of static sites. But for those comfortable working with Drupal it may be difficult to identify the projects that would benefit from a static site build, and also to determine which of the many static site generator options are right for you.
This session aims to provide an overview of the static site generator landscape from a Drupal perspective, including:
- What exactly is a static site generator, and why would I use one with Drupal?
- Navigating potential roadblocks to a static site build
- Approaches to triggering automatic builds based on content updates
- How they differ
- How they interface with Drupal
- Why you might choose one over the other
- Recommended next steps to learn more
By the conclusion of this talk you will have a better understanding of why a static site build may or may not be right for your project, have a better feel for which static site generator would fit your workflow, and may even walk away with some existential questions about the overall nature of dynamic content on the web (heavy, right?)
Managing a CI/CD pipeline for a D8 project can be hard sometimes, starting from scratch is not always the wise option, but there are so many tools in the wild to do what we need… Luckily, lots of them play nice with what we need to do when working on a project but choosing the right one is the key point in order to have a fully automated pipeline and reduce future headaches. In this talk we will go through an overview of some of the CI tools available for us:
- Probo CI
- Circle CI
- Travis CI
- Jenkins CI
We will go through a full pipeline where we’ll build and deploy a D8 project considering automated steps for checking coding standards, functional and unit testing and visual regression.
Drupal 8 Migrations do not need to be as hard as they may seem. Having performed more than 15 Drupal 6/7 migrations to Drupal 8 in the past 3 years I've learned what works and what has left me frustrated. In this session, I will show you what to do to make your process easy and repeatable. You will learn how to:
- Setup and configuration using Lando as a localhost
- What hooks, classes and tricks I use to transform data
- Special modules for special situations
- Explain some of the more popular process plugins
- Cover migrating custom entities and other customizations
- Debugging and troubleshooting a migration
- Issues and workarounds for known problems
By the end of this session, you should have a solid base of knowledge and tools to handle your own migrations.
We've all heard that DevOps is something we should pay to attention to as engineers, but when you are in the day to day struggle of delivering projects, it's easy to feel buried with no clear path for improvement. We've heard there are a plethora of things that we should be doing to achieve this mythical state of DevOps nirvana: maintain perfect culture, automate all the things, test everything, decrease feedback loops, and let the rainbows and unicorns fly while we are at it.
We also know that the real world pace of day to day business makes implementing DevOps nirvana a severe challenge at best and more often than not, it feels impossible. There is so much information out there how do we even know where to begin or what our next step is? What happens if we choose the wrong tool, or get derailed with some new technology we don't have the time to learn properly? How do we even know what to do next?
In this session, we will take a look at what it takes to make progress with DevOps as it relates to your day to day operations. We'll walk through a series of general milestones that you can use as a guiding light, and we will talk about overcoming the fear of failing. You may not leave this session with rainbows and unicorns, but you should be able to take that next small step towards benefiting from DevOps.
Drupal has emerged as a powerful platform to help governments successfully manage open data initiatives. The Drupal distribution DKAN is a community-driven open source open data platform with a full suite of data cataloging, publishing, and visualization features.
Used by countries worldwide - plus U.S. states and federal agencies, including HealthData.gov, the USDA's National Agricultural Library, and the State of California - DKAN is a powerful tool for governments of all sizes to directly open up their data for use by researchers, entrepreneurs, regulatory bodies and citizens. DKAN includes robust web service APIs, built-in compliance with federal and international open data standards, customizable metadata schema mapping, workflow management, data harvesting, and more.
In this talk - a follow-up of last year’s session, “Data to the People,” - we'll explore how organizations are leveraging DKAN to power global government open data efforts and see how it's being used to track school performance, report water quality levels, measure and reduce veteran suicide rates, preview complex geospatial data, empower scientists to perform and share groundbreaking research, and much more.
You’ll learn how government agencies are sharing their ideas and data with one another to build a better world through the DKAN open data community, and how you can get involved as well.
About the speakers:
Stefanie Gray is a longtime DKAN support specialist who has followed the product from its scrappy startup days to its current home at CivicActions, and Dharizza Espinach Barahona is a talented full-stack DKAN developer and support engineer based in Costa Rica.
We’ll be finally meeting in person at DrupalCamp Florida after years of working together to share our experiences from our far-flung remote team! Best of all, we’ve got some great news on DKAN for Drupal 8 to follow up on some of the questions asked at last year’s session.
With the announcement that the Google Search Appliance was End of Life, many universities started looking around for replacement options. At Palantir, we wanted to provide an open source option that could solve the following needs:
- A simple way to store, retrieve, and parse content.
- A cross-platform search application.
- A speedy, usable, responsive front-end.
- A flexible, extensible, reusable model.
- A drop-in replacement for deprecated Google Products
Working with the University of Michigan, we architected and developed a solution. You can read more about it at https://www.palantir.net/blog/introducing-federated-search and come to our session for a live demo.
I started playing with Go Programming Language (golang) several years back (in 2012). It felt like a nifty little language back then. But since then the laguage has picked up so much traction and so many major systems have been built in it that it is hard to ignore.
So what if one were to gather the lessons learnt from Drupal and write a CMS in Go?
What would such a next-generation CMS look like? Would it ...
- run as a tiny docker container to simplify deployment issues?
- provide an API that is not just well documented, but also safe using compilation step?
- run fast in a small footprint?
- scale massively first within a single process (via thousands of concurrent lines of execution - go-routines), and then across containers and servers with auto-scaling?
- push live content updates from server to the client (browser)?
- dynamically load modules as dynamically linked shared libaries (*.so) at runtime?
- learn from the success and pitfalls of existing CMS's like Drupal and WordPress?
At least that's the vision.
Golang has almost everything we need:
- Fully compiled strongly typed programming language with a mature web-stack, garbage collection, high speed at a small footprint (duh!).
- Extreme scalability with channels and go-routines (coroutines). Thousands of active go-routines. Massive concurrency!
- Fully self-contained binary that could be run as a docker container.
- A plugin-based extension system where the main binary could load extra code from at runtime.
- Drivers for almost any database - SQL or NoSQL.
- Web-socket implementations.
So come and join me in imagining, shaping, and then realizing this future.
We spent most of 2018 researching, developing, and communicating ways to deliver headless Drupal Commerce. This included the development of the Commerce Cart API to power progressively decoupled Add to Cart forms and shopping cart interfaces before we turned our attention to supporting decoupled checkout interfaces.
The Commerce Cart API project and the reference implementation in Commerce Cart Flyout demonstrate the results of that initial effort. See it in action on our demo store. Together they put Drupal Commerce on par with other major eCommerce software platforms and hopefully make it easier for Drupal agencies to sell Drupal Commerce as a competitive platform.
That work wasn’t without its challenges. We reviewed the core RESTful Web Services module and JSON API / JSON RPC contributed modules but found unforeseen blockers in adopting either project completely for our work. In this session, Drupal Commerce co-maintainer Matt Glaman will present our comparative analysis of these API architectures, introduce what we developed to meet our needs, and explain how developers can use it to build and improve their stores.
When migrating content from non-Drupal sites you can end up with a lot of junk in your trunk. Wouldn't it be great if you could do cleanup programmatically on the content as part of the migration. This session will demonstate technicques you can use to grab only what you want from the old pages and fix markup issues as part of the migration. Keeping only the good stuff can save a lot of time, energy and prevent embarrassment.
Module: Migration Tools
For quite a while, I've been working with pre-configured gulp files and using the command "gulp watch" to complile my SASS. Recently, I've dug a little deeper to try and understand what Gulp is capable of, how I can customize my workflow with Gulp, and to better understand my alternatives.
This session is a beginners guide to Gulp. We'll start with what Gulp is, what all it is capable of, and whether or not you should use it? We'll take apart the configuration file used by Gulp, gulpfile.js, and show you how to customize it.
Our objective for this session is have participants take away an understanding of what Gulp is, how it can help them in their theming workflow, and how to customize it fully.
Gatsby (https://www.gatsbyjs.org/) is a fun to use web application generator for React that makes it easy to create blazing fast websites. Drupal (https://www.drupal.org/) is one of the most popular open-source content management systems in the world and makes it easy to create unique editorial workflows for your content team.
At it's core, Gatsby uses a system for extracting data from sources like Drupal, and then using that data to generate static pages at build time. The technique allows for many of the benefits of both static sites (speed, ease of deployment, etc.) and those built using a content management system (easy to update, user friendly editorial interface, and more).
What's maybe not obvious on the cover is that the combination of Gatsby and Drupal can also be used to create sites that handle things like user authentication and personalization. Something you don't find in most static sites.
This presentation looks at how you can build a web application that sources content from Drupal, renders ultra-fast static pages with Gatsby, then combines that with traditional React for user authentication and personalization. With the goal of providing attendees with the information they need to get started doing so, and some examples of what's possible.
In this presentation you'll learn:
- Why Gatsby is awesome for static sites
- Why Drupal rocks as an API first content management system
- Why/How to use the two together
- How to handle private content, and other personalization
- Look at a case-study of building a web application that sources content from Drupal, renders ultra-fast static pages with Gatsby, combined with traditional React for user authentication and personalization
WCAG 2.0 was published a decade ago, which is an eternity in Internet years. This past June, the W3 released WCAG 2.1. These new guidelines focus on improving accessibility for users with cognitive disabilities and for users who browse websites on mobile devices, like tablets and smartphones. So what does that mean?
In this session, we’ll answer questions like:
- What’s been added?
- How do I meet these new guidelines?
- What does it replace?
- When does it go into effect?
- How is my organization going to be affected?
- How long do I have?
- What resources are there for testing new WCAG 2.1 guidelines?
- And any other questions you have!