Registration will start at 8am. We'll have a full continental breakfast including coffee, pasteries, and fruit. 

Start the day with FLDC updates, thank yous, and announcements!

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.

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.

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!

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.

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.

Slides

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. 

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 

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.

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?
• What is the JavaScript main thread? How can I optimize for this?
• Identifying, profiling, and optimizing for third party scripts.

In order to get the most out of this session, the attendee will have to 1) have some knowledge of HTML, CSS, and JavaScript, 2) have a basic understanding of browser-based developer tools, and 3) find slow websites extremely annoying.
 

Links: Presentation, sample code.

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 ...

1. run as a tiny docker container to simplify deployment issues?
2. provide an API that is not just well documented, but also safe using compilation step?
3. run fast in a small footprint?
4. 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?
5. push live content updates from server to the client (browser)?
6. dynamically load modules as dynamically linked shared libaries (*.so) at runtime?
7. 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:

1. Fully compiled strongly typed programming language with a mature web-stack, garbage collection, high speed at a small footprint (duh!).
2. Extreme scalability with channels and go-routines (coroutines). Thousands of active go-routines. Massive concurrency!
3. Fully self-contained binary that could be run as a docker container.
4. A plugin-based extension system where the main binary could load extra code from at runtime.
5. Drivers for almost any database - SQL or NoSQL.
6. Web-socket implementations.

So come and join me in imagining, shaping, and then realizing this future.

Links: Presentation, sample code

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:

1. Hubspot and marketing automation/CRM
2. ElasticSearch and search/log management/visualization
3. Cypress.io and modern JavaScript testing
4. GraphQL/Schemata and decoupled web services
5. Pattern Lab and design systems
6. 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.

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

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.

Lunch from world famous Gringos Locos! This is basically an awesome burrito bar, where you can also find vegetarian, vegan, and gluten free meal options. This lunch is included with your ticket!

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

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:

1. Setup and configuration using Lando as a localhost
2. What hooks, classes and tricks I use to transform data
3. Special modules for special situations
4. Explain some of the more popular process plugins
5. Cover migrating custom entities and other customizations
6. Debugging and troubleshooting a migration
7. 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.  

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.

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.

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.

But what if you need to present a dynamic and real-time component for just a small subset of your site’s functionality? Can you have the best of both worlds -- using Drupal as your base and sophisticated JavaScript applications as an enhancement?

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
• The process of adding React applications (or other JavaScript frameworks) as blocks in Drupal
• 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.

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.

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

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
• Documentation
• PHP options
• Windows, MacOS, Linux support
• Integration with hosting platforms

and more...

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

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.

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.

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

We'll also briefly compare three static site generator projects - Jekyll (a Ruby based option), Gatsby (a React based option) and Tome (a Drupal based option), focusing on:

• 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?)

⚡Lightning Talks⚡ are short (5min-ish) impromptu sessions on anything you want. Do you have something you’re proud of? Do you have a new technique that’s saving you time? Have you learned about something cool? Get up and share!

Thank you for coming out. Closing remarks and details about the after party and next day's activities.