Galileo once famously described the universe as a great book "written in mathematical language and its characters are triangles, circles, and other geometrical figures." Unfortunately, it’s a language that many people outside of math and science simply do not speak, largely because they are flummoxed and/or intimidated by the sheer density of all that strange symbolic notation.

Math teacher extraordinaire Ben Orlin is here to help with his latest book: Math for English Majors: A Human Take on the Universal Language. And just like Orlin’s previous outings, it’s filled with the author’s trademark bad drawings. Bonus: Orlin created a fun personality quiz, which you can take here to find out your mathematical style.

Orlin’s first book, Math with Bad Drawings, after his blog of the same name, was published in 2018. It included such highlights as placing a discussion of the correlation coefficient and "Anscombe’s Quartet" into the world of Harry Potter and arguing that building the Death Star in the shape of a sphere may not have been the Galactic Empire’s wisest move. We declared it "a great, entertaining read for neophytes and math fans alike, because Orlin excels at finding novel ways to connect the math to real-world problems—or in the case of the Death Star, to problems in fictional worlds."

In 2019, Orlin took on the challenge of conveying the usefulness and beauty of calculus with tall tales, witty asides, and even more bad drawings in Change Is the Only Constant: The Wisdom of Calculus in a Madcap World. That book is a colorful collection of 28 mathematical tales connecting concepts in calculus to art, literature, and all manner of things human beings grapple with on a daily basis.

Orlin’s most recent book was 2022’s Math Games with Bad Drawings—less a book one reads cover to cover and more a chance for readers to browse randomly at their leisure to find the games best suited to their particular tastes and skills, such as Jotto, a logic-oriented word game invented in 1955 that is similar to Wordle. There were five different categories of games: spatial games, number games, combination games, games of risk and reward, and information games. All could be played with just a few common household items: pencil and paper, coins, colored pens, standard dice, Goldfish crackers, paper clips, your hands, and occasionally an Internet connection. (You can try your hand at a game of Quantum Go Fish here.)

Unlike his prior books, where he carefully avoided most mathematical notation, Math for English Majors is designed to teach readers how to read and interpret mathematical symbols, proofs, and mathematical diagrams. His original vision was to write the math-y equivalent to Lynne Truss’ bestselling Eats, Shoots & Leaves. "It’s a very playful book about English punctuation that weaves together fun stories about the common, the semicolon, and the dash," Orlin told Ars. "But I found that math is just a fundamentally different sort of language, and that template didn’t quite work for me."

Some elements of that earlier vision remain: Math for English Majors talks about numbers as nouns, verbs as calculations, and algebra as grammar, highlighting certain idioms ("exponential") and etymologies "squaring") for good measure.

But Orlin’s main objective is to reconcile the expert’s view of math, "where the notation vanishes and you’re just focusing on the ideas that the notation conveys," with the beginner’s experience of math, "where you can’t even access the ideas because there’s this thick wall of symbolism in the way." Math, says Orlin, is both "a collection of beautiful ideas and a language for expressing those ideas." His approach is the opposite of the usual popularizations of math, where ideas are translated into plain English and notation is largely avoided. Here, the notation is the primary focus.

Ars spoke with Orlin to learn more.

Ars Technica: People who are not mathematically inclined usually see all those abstract symbols and their eyes glaze over. Let’s talk about the nature of symbols in math and why becoming more familiar with mathematical notation can help non-math people surmount that language barrier.  

Ben Orlin: It’s tricky. When I first became a teacher, I was mostly trying to push against students who’d only learned symbol manipulation procedures and didn’t have any sense of how to read and access the information behind them. It always mystified me: why do we teach that way? You end up with very bright, clever students, and all we’re giving them is hundreds of hours of practice in symbol manipulation. But what is a quadratic? They can’t really tell you.

One of the things I’ve gradually come to accept is that it’s almost baked into the language that mathematical notation has developed specifically for the purpose of manipulating it without thinking hard about it. If you’ve had the right set of experiences leading into that, that’s very convenient, because it means that when you sit down to solve a problem, you don’t have to solve it like Archimedes with lots of brilliant one-off steps where you just have gorgeous geometric intuition about everything. You can just be like, "Okay, I’m going to crank through the symbol manipulation procedures." So there’s a real power in those procedures. They’re really valuable and important.

But if it’s all you have, then you’re doing a dance where you know the moves, but you’ve never heard the music. You can’t troubleshoot. Sometimes I wish as a teacher, you could just say, "Look, the symbol manipulation procedures are worthless. We can just skip those and focus on the ideas." But they’re tangled up in a much more complex way. So somehow you have to climb in there with the students and move back and forth between the things that are happening on the page and the ideas that are unfolding in some kind of higher space.

That’s the place this book eventually gets to. But I go there gradually, because you need a lot of experience with symbols that make sense to you before you can feel comfortable when you do manipulations on a page.

Multi-tenancy in web applications refers to the architecture where a single instance of the application serves multiple customers, or ‘tenants.’ Each tenant’s data and, sometimes, specific configurations are kept isolated from others. This setup is essential in SaaS (Software as a Service) platforms where multiple businesses or organizations might use the same application.

In this guide, we’ll walk through setting up a database-per-tenant approach in Laravel, complete with code examples, detailed explanations, and the necessary console commands for creating the database itself with no need or usage of any external package.
Step 1: Setting Up Database Connections
In the config/database.php file, we define two connections:

1. ** Owner Connection**: This connection manages the information about all tenants, such as their domain and database names.
2. **Tenant Connection**: This connection dynamically switches based on the tenant currently being accessed.

Here’s how to set up these connections:

return [
    'default' => env('DB_CONNECTION', 'tenant'),

    'connections' => [
        'tenant' => [
            'driver' => 'mysql',
            'host' => env('DB_HOST', '127.0.0.1'),
            'port' => env('DB_PORT', '3306'),
            'database' => null, // Database will be set dynamically
            'username' => env('DB_USERNAME', 'root'),
            'password' => env('DB_PASSWORD', ''),
            'charset' => 'utf8mb4',
            'collation' => 'utf8mb4_unicode_ci',
            'prefix' => '',
            'strict' => true,
        ],

        ' owner' => [
            'driver' => 'mysql',
            'host' => env(‘OWNER_DB_HOST', '127.0.0.1'),
            'port' => env(,OWNER _DB_PORT', '3306'),
            'database' => env(' OWNER _DB_DATABASE', 'landlord'),
            'username' => env(' OWNER _DB_USERNAME', 'root'),
            'password' => env(' OWNER _DB_PASSWORD', ''),
            'charset' => 'utf8mb4',
            'collation' => 'utf8mb4_unicode_ci',
            'prefix' => '',
            'strict' => true,
        ],
    ],
];

Step 2: Creating the Tenant Model and Migrations
We need to create a Tenant model that uses the landlord connection. This model will manage tenant-related data such as the domain and database name.
Tenant Migration:

In the migration for the tenants table, we’ll include columns for the tenant’s name, domain, and the specific database used:

Schema::create('tenants', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('domain')->unique();
    $table->string('database');
    $table->timestamps();
});

Tenant Model:

The Tenant model should be linked to the landlord connection and include methods for configuring and using the tenant:

class Tenant extends Model
{
    use HasFactory;

    protected $fillable = [
        'name',
        'domain',
        'database',
    ];

    protected $connection = 'owner'; // Default connection for the owner database

    /**
     * Configure the tenant's database connection dynamically.
     */
    public function configure(): self
    {
        // Update the configuration for the tenant connection dynamically
        config([
            'database.connections.tenant.database' => $this->database,
        ]);

        // Purge the 'tenant' connection to refresh its settings
        DB::purge('tenant');

        // Clear tenant-specific cache if cache table exists
        if (Schema::hasTable('cache')) {
            $this->clearTenantCache();
        }

        return $this;
    }

    /**
     * Activate the tenant context across the application.
     */
    public function use(): self
    {
        // Set the default database connection to 'tenant'
        DB::setDefaultConnection('tenant');

        return $this;
    }

    /**
     * Clear cache specific to the tenant.
     */
    public function clearTenantCache(): void
    {
        // Get tenant-specific cache keys
        $cacheKeys = Cache::get('tenant_'.$this->id.'_keys', []);

        // Forget each cache key
        foreach ($cacheKeys as $key) {
            Cache::forget($key);
        }

        // Optionally remove the keys tracking itself
        Cache::forget('tenant_'.$this->id.'_keys');
    }

    /**
     * Add a tenant-specific cache key.
     */
    public function addCacheKey(string $key): void
    {
        // Get the current list of cache keys for the tenant
        $cacheKeys = Cache::get('tenant_'.$this->id.'_keys', []);

        // Add the new cache key
        $cacheKeys[] = $key;

        // Update the list in the cache
        Cache::put('tenant_'.$this->id.'_keys', $cacheKeys);
    }
}

Step 3: Custom Console Command for Tenant initialization 

We will create console command to initialize the owner table where all tenant database info will be stored 

class TenantInit extends Command
{
    protected $signature = 'tenants:init';
    protected $description = 'Create owner table where all domains for tenant app live';

    public function handle(): int
    {
        DB::setDefaultConnection('owner');
        $path = database_path('migrations/owner'); // Custom migration path for the owner DB
        $this->info('Running migrations from: ' . $path);

        try {
            $this->call('migrate', ['--path' => $path, '--force' => true]);
            $this->info('Migrations have been executed successfully.');
        } catch (\Exception $e) {
            $this->error('An error occurred: ' . $e->getMessage());
            return 1; // Return non-zero for failure
        }

        return 0; // Return zero for success
    }
}

Step 4: Custom Console Command for Tenant Migrations

Since each tenant has its own database, we need a way to migrate the schema for each one. Laravel’s built-in migrate command only runs migrations on the default connection, so we’ll create a custom Artisan command to handle tenant migrations.
TenantsMigrateCommand:

This command will loop through all tenants, configure the tenant’s database connection, and run migrations on each database:

class TenantsMigrateCommand extends Command

{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'tenants:migrate {tenant?} {--fresh} {--seed}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Create clean migration and seed for one tenant or for all tenants';

    /**
     * Execute the console command.
     */
    public function handle(): void
    {
        if ($tenantId = $this->argument('tenant')) {
            $tenant = Tenant::find($tenantId);
            if ($tenant) {
                $this->migrate($tenant);
            } else {
                $this->error("Tenant with ID {$tenantId} not found.");
            }
        } else {
            Tenant::all()->each(
                fn ($tenant) => $this->migrate($tenant)
            );
        }
    }

    /**
     * Migrate the given tenant.
     */
    public function migrate(Tenant $tenant): void
    {
        $tenant->configure()->use();
        $this->line('');
        $this->line('-----------------------------------------');
        $this->info("Migrating Tenant #{$tenant->id} ({$tenant->name})");
        $this->line('-----------------------------------------');
        $options = ['--force' => true];
        if ($this->option('seed')) {
            $options['--seed'] = true;
        }
        $this->call(
            $this->option('fresh') ? 'migrate:fresh' : 'migrate',
            $options
        );
    }
}

• {tenant?}: The tenant argument is now optional. If provided, it will run migrations for the specified tenant only.
• {–fresh}: Option to run migrate:fresh, which drops all tables and re-runs all migrations.
• {–seed}: Option to seed the database after running migrations.

Step 5: Middleware for Tenant Resolution

To ensure that the correct tenant is used for each request, we’ll create middleware that identifies the tenant based on the domain and configures the application accordingly.
TenantSessionMiddleware:

class TenantSessionMiddleware
{
    public function handle(Request $request, Closure $next): Response
    {
        if (! $request->session()->has('tenant_id')) {
            $request->session()->put('tenant_id', app('tenant')->id);
            return $next($request);
        }
        if ($request->session()->get('tenant_id') != app('tenant')->id) {
            abort(401);
        }

        return $next($request);
    }}

Step 6: Testing Multi-Tenant Applications
Testing in a multi-tenant environment requires that both the landlord and tenant databases are properly set up before each test. Here’s how you can configure your tests:

public function setUp(): void
{
    parent::setUp();

    // Migrate the owner's database and seed data
    $this->artisan('migrate', ['--database' => 'owner']);
    $this->seed(OwnerSeeder::class);

    // Loop through tenants and migrate their databases
    Tenant::all()->each(function (Tenant $tenant) {
        $tenant->configure();
        $this->artisan('migrate', ['--database' => 'tenant']);
    });
}

Step 7: Setting Up a Service Provider for Tenant Resolution

In a multi-tenant application, it’s crucial to ensure that the correct tenant context is established for each incoming request. This is where a service provider comes into play. The service provider will configure the tenant based on the request’s domain or subdomain, ensuring that the correct tenant’s database and other settings are used throughout the application lifecycle.

Creating the TenancyServiceProvider

<?php

namespace App\Providers;

use App\Models\Tenant;
use Illuminate\Queue\Events\JobProcessing;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Queue;
use Illuminate\Support\ServiceProvider;

class TenancyServiceProvider extends ServiceProvider
{
    /**
     * Register services.
     */
    public function register(): void
    {
        //
    }

    /**
     * Bootstrap services.
     */
    public function boot(): void
    {
        $this->configureTenant();
        $this->configureQueue();
    }

    /**
     * Configure tenant based on the domain.
     */
    protected function configureTenant(): void
    {
        if ($this->app->runningInConsole()) {
            return;
        }

        $host = request()->getHost();
        $tenant = Tenant::whereDomain($host)->firstOrFail();
        $tenant->configure()->use();  // Set up and use tenant configuration
    }

    /**
     * Configure the queue system to be aware of tenants.
     */
    protected function configureQueue(): void
    {
        // Add tenant_id to the job payload
        Queue::createPayloadUsing(function () {
            if (app()->bound('tenant')) {
                $tenant = app()->make('tenant');

                return ['tenant_id' => $tenant->id];
            }

            return [];
        });

        // Restore tenant context when job is processing
        Event::listen(JobProcessing::class, function (JobProcessing $event) {
            $tenantId = $event->job->payload()['tenant_id'] ?? null;

            if ($tenantId) {
                $tenant = Tenant::find($tenantId);
                $tenant?->configure()->use();
            }
        });
    }
}

Expanded Explanation of Service Provider Methods
The methods you’ve shared are essential for managing tenant context both during normal HTTP requests and within Laravel’s queue system. These methods ensure that the correct tenant is always in scope, whether you’re handling web requests or processing background jobs.

Method 1: configureTenant

protected function configureTenant(): void
{
    if ($this->app->runningInConsole()) {
        return;
    }

    $host = request()->getHost();
    $tenant = Tenant::whereDomain($host)->firstOrFail();
    $tenant->configure()->use();  // Set up and use tenant configuration
}

Explanation:

Purpose: This method sets up the tenant configuration based on the incoming request’s domain and ensures that the correct tenant is used throughout the request lifecycle.

if ($this->app->runningInConsole())
{ 
   return; 
}:

This check ensures that the tenant configuration logic only runs during HTTP requests. If the application is running in the console (e.g., during migrations or other Artisan commands), the method will exit early. This is because console commands may not be associated with any particular tenant, and running tenant-specific logic could cause unintended behavior.

$host = request()->getHost();:

This retrieves the domain name from the incoming HTTP request. The domain is typically used to determine which tenant the request is for.

$tenant = Tenant::whereDomain($host)->firstOrFail();:
This line queries the tenants table to find the tenant that matches the domain name. The firstOrFail() method will throw a ModelNotFoundException if no tenant is found, which can result in a 404 error being returned to the user.

$tenant->configure()->use();:
Once the tenant is found, the configure() method sets up the database connection and other tenant-specific configurations.
The use() method then registers this tenant in the service container, making it accessible throughout the application for the duration of the request.

Method 2: configureQueue

/**
 * Configure the queue system to be aware of tenants.
 */
protected function configureQueue(): void
    {
        // Add tenant_id to the job payload
        Queue::createPayloadUsing(function () {
            if (app()->bound('tenant')) {
                $tenant = app()->make('tenant');

                return ['tenant_id' => $tenant->id];
            }

            return [];
        });

        // Restore tenant context when job is processing
        Event::listen(JobProcessing::class, function (JobProcessing $event) {
            $tenantId = $event->job->payload()['tenant_id'] ?? null;

            if ($tenantId) {
                $tenant = Tenant::find($tenantId);
                $tenant?->configure()->use();
            }
        });
    }

Explanation:
Purpose: This method ensures that Laravel’s queue system is tenant-aware. By attaching the tenant_id to the job payload, and reconfiguring the tenant context during job processing, we ensure that the job runs in the correct tenant’s context. This is particularly crucial for distributed queue systems like Redis, where workers could be shared across tenants.

Queue::createPayloadUsing():

This method hooks into the queue system to modify the job payload. The payload is essentially the data that is passed along with a job when it is queued.

if ($this->app->bound('tenant')) {:

This checks if the application has a tenant bound to the service container. If a tenant is bound, it means the current request is associated with a specific tenant.

$tenant = $this->app->make('tenant');:

This retrieves the currently bound tenant from the service container.

return ['tenant_id' => $tenant->id];:

This adds the tenant_id to the job payload, ensuring that the tenant context is passed along with the job when it is dispatched.

return [];:

If no tenant is bound, the payload remains unchanged.

Event::listen(JobProcessing::class, ...):

This listens for the JobProcessing event, which is fired just before a queued job starts processing.

$tenantId = $event->job->payload()['tenant_id'] ?? null;:

This retrieves the tenant_id from the job’s payload. If no tenant_id is found, it returns null.

$tenant = Tenant::find($tenantId);:

This finds the tenant by the tenant_id stored in the payload.

$tenant?->configure()->use();:

If a tenant is found, the configure() method sets up the tenant’s database connection, and use() registers this tenant as the current tenant for the job’s processing context.
You can create a service provider that handles the tenant resolution and configuration. This service provider will hook into Laravel’s bootstrapping process and set up the tenant context at the beginning of each request.
Conclusion
Implementing multi-tenancy in Laravel using a database-per-tenant approach offers strong data isolation and scalability. The steps outlined in this guide provide a complete framework for setting up multi-tenancy, handling migrations, and ensuring that your application uses the correct database for each tenant.

Pros:

• Data Isolation: Each tenant’s data is completely separated, ensuring strong data isolation.
• Scalability: This approach allows easy scaling by adding new databases for new tenants.
• Security: By isolating each tenant’s data in separate databases, the risk of data leakage between tenants is minimized.
• Cache Efficiency: The use of tenant-specific cache keys ensures that only tenant-relevant cached data is cleared, improving performance.
• Queue Robustness: Tenant context is preserved in queues, even in distributed environments, preventing cross-tenant data leakage in background tasks.

Cons:

• Complexity: Setting up and managing multiple databases adds complexity to the application architecture.
• Resource Overhead: Maintaining separate databases for each tenant requires more infrastructure resources.
• Backup Complexity: Managing backups across multiple databases can be challenging, especially when scaling to hundreds or thousands of tenants.
• Migration Overhead: Running migrations for each tenant adds additional overhead compared to a single-database architecture.
• By following this approach, you can build robust, scalable multi-tenant applications in Laravel.

the code example can be locale at  :https://github.com/KalimeroMK/multitenant

You probably think that if you want to check out a museum, you actually have to go there. But that’s not the case anymore, thanks to the popularity of smartphones. Today, with apps like Bloomberg Connects, you can see and learn about collections from all over the world.

What Is Bloomberg Connects, and What Can You Use It For?

Bloomberg Connects is an app for iOS and Android that partners with museums and other cultural institutions across the planet to offer guides to their various collections and exhibits. When you open the app, you’ll see a list of nearby locations you can tap on.

Once you open each individual guide, you’ll be presented with a wealth of info about what you can find there, from current exhibits to the permanent collection, organized in various ways that should suit anyone’s preferences.

Curious about who’s buried in a nearby cemetery? Or do you want to see the latest hot exhibition a museum’s putting on? All these things are spotlighted in Bloomberg Connects, with plenty of pictures and essays to feed your desire for knowledge.

The app also includes maps of each location, so you don’t need to pick up a paper guide at the door when you visit. You can zoom in, which is helpful if you have poor eyesight, and the app also marks the highlights of the institution so that you can easily get to them in person.

What Places Can You Visit With Bloomberg Connects?

Like the Bloomberg organization, which serves as its sponsor, the Bloomberg Connects app is available worldwide. You can find over 550 institutions from over 24 countries, including the United States, Canada, the United Kingdom, Mexico, and Italy.

The types of places available include museums, botanical gardens, historic cemeteries, zoos, theaters, historic houses, monuments, galleries, art walks, and even events like the Venice Biennale. Among these locations are heavy hitters like the Metropolitan Museum of Art, the Art Institute of Chicago, and the Guggenheim. You can check out the full list on Bloomberg Connect’s website, where you’ll find dozens of small institutions too.

However, even if your interest doesn’t lie with museums, Bloomberg Connects has a few interesting collections to check out, like MTA Arts and Design. These are artworks you can see inside the New York City subway system if you’re curious. The app covers a lot of street art and other work you may encounter in your everyday life, like the Project Row Houses in Houston, the Street Art Museum in Amsterdam, and the NYC Health + Hospitals Arts in Medicine program.

How Does Bloomberg Connects Compare With Google Arts & Culture?

There are dozens of museum guides available, many of which are bespoke apps limited to a single institution like the Rijksmuseum or Museo del Prado. The one guide you’re most likely to have heard of and used is Google Arts & Culture, which covers over 2,000 institutions across the world and is available on the web or as an app.

Aside from covering far more places, Google Arts & Culture has an extensive collection of images from most of the institutions it covers, and you can easily search for specific keywords. It’s good for doing art research, looking for inspiration for your own work, or just doing virtual visits of collections.

What Google Arts & Culture isn’t great at is preparing you for visits to real-world locations. It’s difficult to find and browse the list of institutions it covers, and both the app and website are extremely cluttered with various experiments like VR experiences and games—although some Google Arts & Culture web games are worth playing.

In contrast, Bloomberg Connects points you to the nearest locations and tells you everything you need to know to visit, from basics like the hours of operation to guides spotlighting the temporary exhibitions on display. During your visit, you can even look up objects via a number or QR code and enjoy text or audio commentary.

There’s no clear "winner" between the two, as they essentially are designed to do different things. For art lovers, both services are worth having in your arsenal. But when it comes to what app you should have on your phone, Bloomberg Connects is definitely worth keeping around for your next trip.

• Overall length
  7.5"
• Blade length
  3.3"
• Blade steel
  D2
• Blade shape
  Drop point
• Grind
  Flat
• Hardness
  60-62 HRC
• Lock type
  Crossbar
• Carry
  Right hand, Tip-up
• Weight
  2.9 oz.

• Hardworking D2 steel

• Highly reliable crossbar lock

• Great ergonomics & fast, clean operation

• Unbeatable price

• Extremely high demand and limited stock

Tiled windows have a gap, or margin, by default, but you can change that.

By default, macOS Sequoia leaves a neat gap between windows when they are tiled — but if you don’t like that, it’s easy to change it.

How to turn off the gaps in Window Tiling

At first, the term "multi-tenancy" might sound like a technical challenge, but it’s actually a straightforward strategy for organizing software to serve multiple users seamlessly. While the concept itself is simple to grasp, its implementation can vary depending on the specific needs of different applications.

Let’s begin by defining what multi-tenancy really means.

Multi-tenant SaaS applications are a type of software that allows multiple users to access the same software instance. This is achieved by partitioning the software into separate, isolated environments that are dedicated to each tenant. Customer data could be stored in a separate database for each tenant, or in a shared database with data assigned to tenants by unique identifiers.