Announcing Percona Live ONLINE – A 24-Hour Virtual Event
https://ift.tt/3c9a8QG
We are excited to announce Percona Live ONLINE, a stand-alone virtual event we’re bringing to the community. It’s totally free of charge, and available for everyone to attend, no matter where you are in the world!
Percona Live ONLINE is not intended to replace our in-person Percona Live conferences in Europe and North America. We’re still on track to bring you Percona Live Europe in Amsterdam, October 19-21, 2020.
However, given the current circumstances, it seemed like a good time to introduce an online version of Percona Live to a wider audience. We’ll be featuring topics and speakers showcasing the latest trends in open source database technology.
The conference will be a true follow-the-sun event running for a full 24 hours kicking off at 10:00 am Eastern time on May 19, 2020, with some exciting keynote speakers. This allows users in EVERY timezone to be able to participate — like a hackathon, but for database content! Look for the full agenda to be released next week.
How Are We Selecting the Speakers?
Normally we’d run a call for papers but as we’d already gone through a selection process for our Austin event, we’re pleased that many of the speakers we have reached out to have said that they would be willing to support this great new online initiative.
With just a single track planned for Percona Live ONLINE, we’re currently working on creating a balanced agenda that will embrace MySQL, MongoDB, MariaDB, PostgreSQL, Kubernetes, cloud… and more!
There will be a limited number of speaking spaces so if you don’t receive an invite the first round, we will look at a second event and hope to get those speakers on the agenda then!
Will We Be Featuring Sponsors for Percona Live ONLINE?
The companies that sponsor the in-person Percona Live events enable us to deliver conferences of high standards in desirable locations. Without them, we simply could not present conferences to the standards our community has come to expect. In return, sponsors get an opportunity to engage with attendees and showcase their products and services. They know that they’ll get a great return on their investment!
Percona Live ONLINE is a new concept and heavily focused on the community aspect. Although we are confident that it will be a huge success, without known outcomes, we have decided not to solicit sponsorship for this event. We will revisit this for future events if we think that we can offer benefits to sponsors and participants alike.
How Can I Access the Conference?
We encourage you to pre-register to ensure you receive the latest information on the agenda, as well as streaming links for the conference. It is totally free to register and participate! Pre-register today!
Been There, Got the T-Shirt?
Many of those who have attended Percona Live conferences collect our unique event T-shirts.
Well, fear not! We will have a limited-edition t-shirt this year as well, but you’ll have to earn it! Make sure to follow the chat during the conference live streams to find out how to get one.
We’ll also be offering some cool prizes during the event. Stay tuned for more news!
Where Can I Interact With Other Online Attendees During the Conference?
We will have dedicated chat rooms and a live chat feed throughout the conference. Please pre-register so that we can send you details on how to access these.
Will I Be Able to Access Recordings If I Miss Some Sessions or Fall Asleep During the Event?!
Recordings of sessions will be made available shortly after the conference ends so you’ll be able to access them later. But honestly… we don’t think anyone is going to be sleeping!
We look forward to seeing you all virtually on May 19! Use #PerconaLive to stay up to date with the latest news and happenings!
Six years ago Laravel Cashier was released just before Laracon with the goal of being an easy to use subscription billing system that ties directly into Stripe. Since then Cashier has continued to get a lot of nice upgrades and this week the Laravel team released a brand new version, Cashier v11, that introduces support for Stripe’s Multiplan Subscriptions and a new Tax Rates feature.
The Multiplan subscriptions allow you to assign multiple billing plans to a single subscription. This is useful if you allow up-sales or secondary features. Then the new Tax Rates feature allows you to apply a tax rate on a model-by-model basis, which could be helpful if your customers span multiple countries or tax zones.
With the release of V11, some of the requirements have also changed and these include:
PHP version v7.2+
Laravel v6.0+
Stripe SDK v7.0+
It also requires some new migrations and you should follow the upgrade guide for complete details.
Developers may have a hard time adapting to the frontend environment. There are several challenges, for example learning how to work with a new library for the construction of interfaces, such as ReactJs, VueJs or simply Javascript. It’s good for developers to have experience in these technologies, though they have a logarithmic learning curve.
It’s for this reason that this time I bring you a guide to a framework for Laravel that is trending at the moment: Livewire.
What’s Livewire?
It comes as an attractive solution for developers since it allows building user interfaces as PHP components without the need to use reactive javascript.
Livewire is defined as a full-stack framework for building dynamic interfaces. With this framework you can build user interfaces through PHP classes, which allows backend developers to work in an environment they are used to work in.
How does it work?
When we visit a page, in the first load of the interface, Livewire is responsible for rendering the component as a simple blade and injecting the HTML result to the requested page.
Then the magic happens, every time actions are triggered due to user interactions with the interface, requests (AJAX) are executed, which returns the rendered HTML with the corresponding changes. Then it is again injected into the page.
Finally, the library automatically detects the changes that need to be done to the DOM, updating only what’s necessary.
The challenge
We will venture into the implementation of a product catalog, which will have a simple shopping cart for checkout. It will also be able of adding and removing products from it. The objective is to understand how it works and the most important characteristics of this package.
Enough with theoretical aspects… let’s get to work!
First of all we will initialize a Laravel project from scratch. To do this, we execute:
The next step is to configure the project. First, you should configure the .env file and then install and configure livewire.
composer require livewire/livewire
After finishing up these first two stages, we will create the product’s entity with its model, migration, factory and data seeder. This is how we obtain fake data to run tests with the project. Then, execute the following command:
php artisan make:model -msf Product
– m | creates migration
– s | creates seeder
– f | creates factory
Now it’s time to update the content of the files created by the command:
<?php use Illuminate\Database\Migrations\Migration; use Illuminate\Database\Schema\Blueprint; use Illuminate\Support\Facades\Schema; class CreateProductsTable extends Migration { /** * Run the migrations. * * @return void */ public function up() { Schema::create('products', function (Blueprint $table) { $table->id(); $table->string('name'); $table->string('description'); $table->float('price'); $table->timestamps(); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::dropIfExists('products'); } }
<?php /** @var \Illuminate\Database\Eloquent\Factory $factory */ use App\Product; use Faker\Generator as Faker; $factory->define(Product::class, function (Faker $faker) { return [ 'name' => $faker->word, 'description' => $faker->text(180), 'price' => $faker->numberBetween(50, 100) ]; });
database/factories/ProductFactory.php
<?php use App\Product; use Illuminate\Database\Seeder; class ProductSeeder extends Seeder { /** * Run the database seeds. * * @return void */ public function run() { factory(Product::class, 50)->create(); } }
database/seeds/ProductSeeder.php
<?php use Illuminate\Database\Seeder; class DatabaseSeeder extends Seeder { /** * Seed the application's database. * * @return void */ public function run() { $this->call(ProductSeeder::class); } }
database/seeds/DatabaseSeeder.php
Thanks to these changes we are ready to execute the next command while having data to work with.
php artisan migrate:fresh --seed
If everything was correctly executed, this message should appear at the end of the console: “Database seeding completed successfully.”
In this case, we’ll manage the state of the shopping cart with a Laravel session. We’ll create a facade that manages it using basic operations to obtain, add and remove products. I won’t explain how to configure a facade in Laravel because it’s not part of the guide’s objective. Our facade should look like this:
<?php namespace App\Helpers; use App\Product; class Cart { public function __construct() { if($this->get() === null) $this->set($this->empty()); } public function add(Product $product): void { $cart = $this->get(); array_push($cart['products'], $product); $this->set($cart); } public function remove(int $productId): void { $cart = $this->get(); array_splice($cart['products'], array_search($productId, array_column($cart['products'], 'id')), 1); $this->set($cart); } public function clear(): void { $this->set($this->empty()); } public function empty(): array { return [ 'products' => [], ]; } public function get(): ?array { return request()->session()->get('cart'); } private function set($cart): void { request()->session()->put('cart', $cart); } }
Cart.php
Now that our facade is configured properly we can start developing our catalog. We’ll be using TailwindCSS to structure and style the application. In order to add this dependency we will follow the following steps:
We now need to define our layout. Livewire will automatically search for a layout named app.blade.php and render the components by default where we define the content section:
To ease the access to the different views, we should add a navigation bar and create a new file called resources/views/layouts/header.blade.php with the following content:
Now we’re ready to start creating components with Livewire. We’ll start creating a component for the home interface, in which we want to show a welcome message.
To do this, we will execute the command php artisan make:livewire Home which will automatically add two new files in the project. The first one contains all the logic of the components and the other one contains all the HTML linked to it. It’s worth mentioning that this last one is a blade file, so we can use the same blade directives we’re used to using in Laravel.
The views files are in resources/views/livewire , we must add content to the file home.blade.php within the existing route tag <div>.
! Don’t forget that the blade file must have only one root element.
The next step is to modify the route’s answer so that Livewire can take control of the route and render the component within the section ‘content’ defined in the layout.
Let’s now modify the file web.php, it should be seen this way:
<?php use Illuminate\Support\Facades\Route; Route::livewire('/', 'home')->name('home');
routes/web.php
! Livewire’s library automatically searches for a component named home within the directory app/http/livewire
If we now run our project with php artisan serve and access to http://localhost:8000 this is what we’ll see:
If you can see this view, you’re on the right track! You can now move forward to the construction of our product catalog. We’ll again create a Livewire component with this command:
php artisan make:livewire Products
The ‘Products’ component will have the following content:
<?php namespace App\Http\Livewire; use App\Product; use App\Facades\Cart; use Illuminate\View\View; use Livewire\Component; use Livewire\WithPagination; class Products extends Component { use WithPagination; public $search; protected $updatesQueryString = ['search']; public function mount(): void { $this->search = request()->query('search', $this->search); } public function render(): View { return view('livewire.products', [ 'products' => $this->search === null ? Product::paginate(12) : Product::where('name', 'like', '%' . $this->search . '%')->paginate(12) ]); } public function addToCart(int $productId): void { Cart::add(Product::where('id', $productId)->first()); } }
Here we will see functions with different objectives. The ‘mount’ function will always be executed before the ‘render function’. It’s where we should define the logic that involves the data that will be rendered later.
The ‘render’ function is in charge of rendering the blade file. It’s executed the first time the page is loaded and every time there’s an interaction with the page (whenever a user interacts with the different visual components).
We also have the ‘addToCart’ function, which can be called from the view. For example: On a button click.
As we can see in line 3, the ‘search’ attribute is used as the model in the input. This means that every time a change is made in the input, the component will be updated with the new value of the input. This ends up in the execution of the ‘render’ function once again.
We’ll also use the following layout for the product pagination.
It’s time to define the route ‘/products’ to make our component work. To do this, we modify the file web.php.
<?php use Illuminate\Support\Facades\Route; Route::livewire('/', 'home')->name('home'); Route::livewire('/products', 'products')->name('products');
routes/web.php
After defining this, if we access to the route /products we’ll obtain the following result:
At this point we can filter the products by their name, as well as add them to the shopping cart.
The next step is to create the shopping cart interface. By doing that we’ll be able to see the products, remove them and finish the checkout process. Now execute the following command:
php artisan make:livewire Cart
Add the following content to the files app/Http/Livewire/Cart.php and resources/views/livewire/cart.blade.php
<?php namespace App\Http\Livewire; use App\Facades\Cart as CartFacade; use Livewire\Component; class Cart extends Component { public $cart; public function mount(): void { $this->cart = CartFacade::get(); } public function render() { return view('livewire.cart'); } public function removeFromCart($productId): void { CartFacade::remove($productId); $this->cart = CartFacade::get(); } public function checkout(): void { CartFacade::clear(); $this->cart = CartFacade::get(); } }
app/Http/Livewire/Cart.php
We’ll obtain the status of the shopping cart in the mount() function. This way we’ll be able to show the existing products in the view.
We should define the function ‘RemoveFromCart’, which will be in charge of removing a product (using its ID) from the shopping cart. It’s important to notice that this job is delegated to the facade.
There’s also a function called ‘checkout’ that makes the checkout and removes all the products from the shopping cart.
This is probably the interface in which we use the blade directives the most. We can verify the existence of products in the shopping cart in the line 4. If they do exist, the elements will be listed. If there are no existing elements, a message will be displayed saying that there are no products in the shopping cart.
Notice that each product is associated with a button. Every time the click event is executed, the function RemoveFromCart – defined in the component – is activated and will remove the element from the shopping cart.
What’s left? Updating the file web.php, which should now be seen this way:
<?php use App\Http\Controllers\HomeController; use App\Http\Controllers\ProductsController; use Illuminate\Support\Facades\Route; Route::livewire('/', 'home')->name('home'); Route::livewire('/products', 'products')->name('products'); Route::livewire('/cart', 'cart')->name('cart');
routes/web.php
Finally, if we add a product to the shopping cart and access a /cart, we should get to the following view:
Activating the SPA mode
To activate this navigation mode, the first thing we should do is install the turbolinks dependency. This dependency automatically injects the received HTML without reloading the page. To install it, we use: npm install --save turbolinks
After this, we must update the app.js file, which should contain this content:
require('./bootstrap'); var Turbolinks = require("turbolinks") Turbolinks.start()
resources/js/app.js
Finally, we execute npm run watch
If we head back to our project in the navigator, we’ll be able to see how it’s exchanged throughout the different pages, without reloading the site.
Product counter (optional)
We can also add a product counter in the shopping cart. For this we will use events and listeners of the Livewire components. The logic behind this functionality is to issue notifications every time a new product is added to the shopping cart and every time it is removed. We need a component to listen to those events and updates when it does.
To do this, we’ll need to modify our project a little bit, the first thing we will do is create a new header component
php artisan make:livewire Header
We modify the generated files in the following way:
<?php namespace App\Http\Livewire; use Illuminate\View\View; use Livewire\Component; use App\Facades\Cart; class Header extends Component { public $cartTotal = 0; protected $listeners = [ 'productAdded' => 'updateCartTotal', 'productRemoved' => 'updateCartTotal', 'clearCart' => 'updateCartTotal' ]; public function mount(): void { $this->cartTotal = count(Cart::get()['products']); } public function render(): View { return view('livewire.header'); } public function updateCartTotal(): void { $this->cartTotal = count(Cart::get()['products']); } }
We don’t need the file we were including in the header anymore because we’re now using our component, so we can delete the file.
Now we must modify the function that adds and removes products from the shopping cart. We’ll modify app/Http/Livewire/Products.php y app/Http/Livewire/Cart.php respectively.
public function addToCart(int $productId): void { Cart::add(Product::where('id', $productId)->first()); $this->emit('productAdded'); }
app/Http/Livewire/Product.php
public function removeFromCart($productId): void { CartFacade::remove($productId); $this->cart = CartFacade::get(); $this->emit('productRemoved'); } public function checkout(): void { CartFacade::clear(); $this->emit('clearCart'); $this->cart = CartFacade::get(); }
app/Http/Livewire/Cart.php
Conclusions
One of Livewire’s best advantages is the possibility to construct user interfaces with PHP’s simplicity. It would be much complex to build the same thing using javascript and would require more learning and development time.
I guess that another amazing advantage is the possibility of using all the resources Laravel Core provides us in Livewire’s class components. This unifies both environments.
Livewire came here to stay, willing to set an ecosystem in which backend developers feel free to implement solutions with PHP in both, frontend and backend.
When it comes to B2B lead generation, what impacts the most?
Many B2B business houses tend to spend a lot of time, pouring water into leaky buckets. Rather than fixing the bucket i.e. the marketing funnel, they pour more water i.e. traffic into the bucket to keep it to the brim. This tendency leads to inflated acquisition costs and below-average results in terms of generating leads.
Landing pages are most crucial, particularly- the forms. Forms separate your leads from non-leads. Structures on your website indicate on your conversion rates and overall lead generation results.
Let’s say around 1000 people visit your landing page, maybe about 1% tends to convert. The fundamental reason is that most people tend to procrastinate, some feel that they will convert late, and some tend to find a different alternative. So what is to be done now? An urgency arises, in such a situation to turn at the moment. Here comes the main gameplay of optimizing your website for conversion. It is an ongoing process. There is always a next step you can take to bring in more leads and make that 1% go up the chart.
You must be feeling a dire need to optimize your website for lead generation. Questions might arise in your mind like how do I improve my landing page? What strategies should I follow? How to get more website leads?
Exclusively for you, we are covering website lead generation best practices that will help experienced business owners to take the next step in optimizing their website for lead generation and conversion, Let’s begin!
A website is one of the most potent tools most business owners possess when it comes to generating leads.
All potential new leads should be brought back to your website aka remarketing
When a person visits your website, there are several ways in which you can get them to convert i.e. (content marketing, email marketing, lead nurturing, Social media marketing)
Map Your Customer Journey and Website Flow
It is evident that when a person visits your website’s homepage, it needs more than some kind of action in order to convert and become a lead. If each step is not transparent, it becomes hard for visitors to convert.
A clear path needs to be set for visitors to follow through the website to convert from just leads to buyers. The more, the merrier is the motto. It means that the website must draw more traffic and every page of your website has to correspond to the ideal customer journey that you want visitors and leads to follow.
Every website and growth agency lead generation efforts start and end with that path, implying that every web page you create has to serve as a specific stepping stone toward conversion.
Every step should build a bridge towards the next step.
One of the ways to approach this outlook can be using Google Analytics Behavior Flow and filter for website visitors who become your best leads and best customers. It indicates which pages target audience visited along the way and help you identify where in the journey potential leads who did not convert fall off.
Google Analytics Behavior Flow
Build One Landing Page for One Persona (Buyer)
One of the biggest mistakes that most B2B business houses make with their website is that they use the same content to attract different segments of their customer base. If you create a landing page designed to convert all of your buyer personas, chances are, it will not be so effective since every buyer has a different opinion, mindset and preference.
It is therefore needed to create multiple landing pages –
“one for each of your buyer personas“
Let’s say you create a landing page exclusive that addresses the pain points of your audience, and another landing page for your visitors who visits due to interest, create one landing page for end-users focusing on your product and a separate landing page for their managers, so on and so forth.
Breaking out separate landing pages in that way, can get even more target audience and is effective to bring in “quality leads“
Send a Consistent Message All Over Your Digital Presence
The message you are sending to your target audience, if inconsistent, creates a mismatch in their expectations. If your website does not do what it promises its target audience, then it leads to
High exit rate of the visitors
Lower conversion rate
Poor user experience
Issues like High exit rate, high bounce rates, and low session durations can also negative effect.
According to Google, “the experience you offer affects your Ad Rank and therefore your CPC and position in the ad auction.”
The solution to these problems is to ensure everything that leads visitors to a given page of your website sends the same message and sets the same expectations.
Example –
Your advertisement copy – paid social media ads, display PPC ads, Google Ads, etc.
Your SEO, meta title and meta description
Social media posts
Get Your Capture Form Right
If you want to convert website visitors into leads, then you need to have some kind of capture form included in your website design. That is “Basic Marketing 101“.
To generate better-qualified leads, you will need to take it a step further and optimize your capture form for not only your unique audience but also for your business.
The best method is to offer something your audience deems valuable in exchange for their information. Basic -” helps them solve a problem” like a 30-minute consultant call or a quick chat.
Balance the type and amount of information you gather (like phone numbers and other contact information) with that perceived value. The more value your visitors expect to get from you, the more information they will be willing to hand over.
Conversion optimization activities, optimizing your form’s Call To Action and submit buttons also falls under this best practice along with a combination of placement, web design, and A/B testing.
Use Retargeting to Capture (Who Didn’t Convert)
No matter how consistent and compelling your website might be, there will always be visitors who fit the persona of your best leads but still do not convert – the worst part of digital marketing. It does not imply that those potential customers disappear and they cannot be converted. This is where “Remarketing “ makes its marks.
The biggest disadvantage of retargeting advertisements only target one individual, and most of the times that do not work for B2B businesses. You need to find tools that will allow you to target retargeting advertisements to an entire business/organisation. For this, it is recommended to use website visitor identification software along with some retargeting tools that focus on B2B.
Conclusion
Majority of website visits end without conversion, but there is always something more you can do to get more qualified companies to convert into leads. With the best practices above, you can take it to the next step and start generating more and more qualified website leads and increase your business profitability. Experiment with them to see exactly what works for you. Test the methods that convert the most, test the lead magnets that will convert best. Keep testing until you find what works best for your target audience and this helps you acquire more leads, make more sales. Tell us what do you feel?
In the right hands, a whip can be an incredibly painful and precise weapon. But most of the whips we’ve seen are made from leather or paracord. This TikTok clip posted by masterlolik_yt shows how a heavy length of chain can be even more dangerous as a whip as it literally makes oranges explode on contact. More here.
We’ve seen lots of nifty objects made from old skateboard decks, but what Woby Designs is showing off here is something different. By laminating together 20 wood decks, he was able to create a usable lumber with a colorful pattern running through its center. The prep work looks like the most time-consuming part.
Netflix now lets you lock your personal profile with a PIN to keep kids (and roommates) out
https://ift.tt/34kLfPh
Want to let your kids poke around Netflix without them wandering their way beyond the kids section? Got a roommate who keeps inexplicably forgetting to use their profile and is totally screwing up your “Continue Watching” list?
Good news! Netflix is now letting users set a PIN to keep individual profiles locked down.
The new feature comes as part of a wider update this morning focusing on improved parental controls.
Other new features include:
Filtering titles based on their maturity rating in your country. Useful if you want someone to have access to more than just the kids section while still blocking off anything beyond, say, PG-13.
Disabling auto-play on a kid profile to make Octonaut marathons a bit more… intentional.
Blocking specific titles by name. Need a break from Boss Baby? Maybe add it to the list for a while.
It’s all pretty basic stuff… but with more people working from home with kids in tow right now, it’s a good time for all of it to land.
Looking for the new controls? Visit Netflix.com in a browser, make sure you’re toggled into a non-kid profile, tap the dropdown arrow in the upper right, hit “Account”, then look for the “Profile & Parental Controls” section — everything should be nested in there, with individual settings for each profile on your account.
With the help of Tac Gas, drone pilot NURK FPV had the rare opportunity to visit an abandoned gas and oil platform. There, he zigged and zagged his aerial camera through the rusted out facility, capturing some fascinating and truly unique visuals. The over-water footage had us hanging on for dear life.
This portable cooker works differently from other propane grills. Rather than open grates, the Firedisc has a smooth surface that can cook just about anything you’d make in a pan or a griddle, from eggs to pancakes to meats, and you can even use it as a fryer. Its curved edges keep food warm, while its center cooks nice and hot.
We are excited to announce Percona Live ONLINE, a stand-alone virtual event we’re bringing to the community. It’s totally free of charge, and available for everyone to attend, no matter where you are in the world!
