DEV Community: Gun

Building an SEO competitor-analysis Actor with Crawlee and Apify

Gun — Wed, 24 Jun 2026 10:03:31 +0000

I manage a client's small blog where I regularly publish comparison articles, the kind that rank for queries like "best project management tools" or "windows OS alternatives." After a while, I noticed a pattern: competitors ranking above me weren't necessarily covering more topics, they were just structuring their content differently. I wanted to understand exactly what they were covering that I wasn't.

My first instinct was to manually open each page, scan the headings, and take notes. That worked for one or two pages. It didn't scale. So I built a Crawlee Actor that does the comparison for me, extracting heading structures from my page and competitor pages, cleaning and normalizing them, and producing a structured JSON output that shows shared topics, missing coverage, and unique sections.

This article walks through how I built it, what broke along the way, and how I ended up with something reliable enough to run on a monthly schedule.

Prerequisites

To follow along, you'll need:

Node.js v18 or higher
The Apify CLI installed (npm install -g apify-cli)
Basic familiarity with JavaScript and async/await
An Apify account (free tier works fine)

What the Actor does

By the end of this guide, I'll have a Crawlee Actor that:

Crawls my page and competitor pages targeting a given topic
Extracts structured headings (H2, H3, H4) from real article content
Removes noise from widgets, sidebars, and injected elements
Normalizes headings into comparable values
Extracts meaningful entities from headings
Compares my page against competitors
Returns a structured JSON output with:
- shared sections
- missing topics
- unique coverage

This output gives me a usable baseline for content gap analysis, without opening a single competitor page manually.

Why this problem is harder than it looks

At first, comparing pages sounds straightforward. Extract headings from your page, extract headings from competitor pages, and compare them. In practice, this breaks quickly.

Real-world pages are not clean. They mix actual content with unrelated elements that interfere with extraction. Some of the most common issues I ran into:

Noisy sections: Pages often include sidebars, "related articles", newsletters, and promotional blocks. These elements contain headings that are not part of the core content but still get scraped.
Inconsistent structure: One page may list tools under H2 headings, while another uses H3 or even plain text. The hierarchy is not reliable across sites.
Injected or styled content: Some sites inject styles or scripts directly into heading elements. Instead of clean text, I was extracting CSS fragments or broken strings like .css-19a5n3-link{color:#0a0a23}.
Ambiguous headings: Headings like "Best options for teams" or "Top picks" don't clearly identify what they refer to. They are not usable for comparison without further processing.
Different wording for the same concept: One page may use "Linux Mint", another "Mint Linux". Without normalization, these appear as different items.

If you stop at raw extraction, the output becomes noisy and misleading. The real challenge is not scraping — it is isolating the actual article content, removing irrelevant sections, normalizing headings, extracting meaningful entities, and making the data comparable across pages.

Project setup

I started by creating a new Crawlee project and installing the required dependencies. If you're starting from scratch:

npx crawlee create seo-content-gap-analyzer
cd seo-content-gap-analyzer

If you already have a project, install Crawlee:

npm install crawlee

Since this workflow is designed to run as an Actor, I also installed the Apify SDK:

npm install apify

All the main logic lives in a single entry file:

src/main.js

That's all the setup I needed to get started.

Defining the Actor input

The Actor needs two main inputs: my page (the one I want to analyze) and competitor pages (used for comparison). I also included a topic label and a few optional settings. Here's an example input for Windows OS alternatives:

{
  "type": "comparison",
  "topic": "windows os alternatives",
  "myPage": "https://your-site.com/windows-os-alternatives",
  "competitors": [
    "https://example.com/windows-alternatives",
    "https://example.com/best-windows-alternatives",
    "https://example.com/linux-vs-windows-alternatives"
  ],
  "maxRequests": 20,
  "debug": true
}

Input breakdown

type: Defines the output mode. Here, I'm running a comparison workflow.
topic: A label describing what the analysis is about.
myPage: The page I want to evaluate.
competitors: A list of URLs ranking for the same topic. These serve as the comparison baseline.
maxRequests (optional): Limits how many pages the crawler processes.
debug (optional): Enables additional logging during execution.

At runtime, the Actor will crawl my page and each competitor page, extract heading structures from all of them, then compare everything to identify overlaps and gaps. This input structure keeps the workflow flexible and reusable across topics. If you want to add validation or a UI for your inputs, the Actor input schema specification covers how to set that up.

Crawling strategy

For this workflow, I used CheerioCrawler. This was a deliberate choice. I'm not interacting with pages, clicking buttons, or handling dynamic user flows. The goal is to extract structured content from article pages as efficiently as possible. CheerioCrawler gives me:

fast HTML parsing
low resource usage
simple DOM traversal
enough control to clean and process content

Using a browser-based crawler like Playwright would increase complexity and cost without adding real value for this use case.

Working with real-world comparison pages quickly exposed edge cases that don't appear in simple demos. The main challenge was not crawling itself, but handling inconsistent and deeply nested HTML structures. Some pages exposed tools cleanly, while others embedded them inside component-based layouts, mixed with styling layers and editorial content.

To make the crawler reliable, I focused on three areas:

Text normalization: to remove CSS fragments and presentation artifacts before processing
Entity filtering: to separate actual tools from scores, features, and editorial sections
Flexible matching: to handle variations in naming across pages

These adjustments didn't change how the crawler works at a high level, but they significantly improved the quality of the extracted data.

What I actually need from each page

I'm not scraping the entire page. I only care about the main article content, heading structure (H2, H3, H4), and meaningful text inside those headings. Everything else is noise.

const crawler = new CheerioCrawler({
    maxRequestsPerCrawl: 10,
    async requestHandler({ request, $, response }) {
        const url = request.url;
        const title = $('head > title').first().text().trim() || null;
        const metaDescription = $('meta[name="description"]').attr('content')?.trim() || null;
        const h1 = $('h1').first().text().trim() || null;
        const canonical = $('link[rel="canonical"]').attr('href') || null;
        const statusCode = response?.statusCode || null;
        $('aside').remove();
        $('.sidebar').remove();
        $('.widget').remove();
        $('.related').remove();
        $('.latest').remove();
        $('.recommend').remove();
        $('.newsletter').remove();
        removeWidgetBlocks($);
        const articleRoot = getArticleRoot($);
        let h2List = [];
        articleRoot.find('h2').each((i, el) => {
            const normalized = normalizeHeading($(el).text());
            if (normalized && !ignoredHeadings.includes(normalized)) {
                h2List.push(normalized);
            }
        });
        let h3List = [];
        articleRoot.find('h3').each((i, el) => {
            const normalized = normalizeHeading($(el).text());
            if (normalized && !ignoredHeadings.includes(normalized)) {
                h3List.push(normalized);
            }
        });
        h2List = uniqueList(h2List);
        h3List = uniqueList(h3List);
        await Actor.pushData({
            url,
            pageType: url === myPage ? 'myPage' : 'competitor',
            title,
            metaDescription,
            h1,
            h2List,
            h2Count: h2List.length,
            h3List,
            h3Count: h3List.length,
            canonical,
            statusCode,
            checkedAt: new Date().toISOString(),
        });
    },
});
await crawler.run([myPage, ...competitorUrls]);
await Actor.exit();

Here's what the initial extraction looks like for three of the pages I tested:

Adding a comparison snapshot

At this point, each page was returning structured headings — useful, but not yet comparable. To get a global view, I introduced a comparison layer that aggregates all pages into a single snapshot. The goal is not to change extraction, but to summarize what appears across pages, what is missing from my page, and what is unique.

const result = {
  type: "comparison",
  topic,
  sharedHeadings: [],
  myPageOnlyHeadings: [],
  competitorOnlyHeadings: []
};

I added a helper function just below uniqueList():

function compareHeadings(myPageData, competitorsData) {
    const myItems = uniqueList(
        [...myPageData.h3List, ...(myPageData.h4List || [])]
            .filter(isMeaningfulHeading)
            .map(extractLabel)
            .map(normalizeComparisonLabel)
            .filter(looksLikeEntityLabel),
    );

    const compItems = uniqueList(
        competitorsData
            .flatMap((c) => [...c.h3List, ...(c.h4List || [])])
            .filter(isMeaningfulHeading)
            .map(extractLabel)
            .map(normalizeComparisonLabel)
            .filter(looksLikeEntityLabel),
    );

    const sharedHeadings = [];
    const myPageOnlyHeadings = [];
    const competitorOnlyHeadings = [];

    for (const myItem of myItems) {
        const hasMatch = compItems.some((compItem) =>
            areHeadingsSimilar(myItem, compItem)
        );

        if (hasMatch) {
            sharedHeadings.push(myItem);
        } else {
            myPageOnlyHeadings.push(myItem);
        }
    }

    for (const compItem of compItems) {
        const hasMatch = myItems.some((myItem) =>
            areHeadingsSimilar(compItem, myItem)
        );

        if (!hasMatch) {
            competitorOnlyHeadings.push(compItem);
        }
    }

    return {
        sharedHeadings: uniqueList(sharedHeadings),
        myPageOnlyHeadings: uniqueList(myPageOnlyHeadings),
        competitorOnlyHeadings: uniqueList(competitorOnlyHeadings),
    };
}

This doesn't change the crawler itself. It adds a snapshot layer on top of the extracted data — one summary that shows how my page compares to the rest. After the crawl finishes, I load the dataset and split results into myPage and competitor entries:

const { items } = await dataset.getData({ limit: 1000 });

const myPageData = items.find((item) => item.pageType === 'myPage');
const competitorsData = items.filter((item) => item.pageType === 'competitor');

Then I run the comparison and store the snapshot:

if (myPageData && competitorsData.length > 0) {
    const comparison = compareHeadings(myPageData, competitorsData);

    console.log('Comparison Result:', comparison);

    await Actor.pushData({
        type: 'comparison',
        ...comparison,
        generatedAt: new Date().toISOString(),
    });
}

This gives a first global view of the topic: sharedHeadings shows overlap between my page and competitors, myPageOnlyHeadings shows content covered only on my page, and competitorOnlyHeadings shows content competitors cover that my page doesn't.

Testing the crawler on another topic

At this point, the crawler worked for one dataset. The next step was to check whether the logic held when the topic changed. Instead of modifying the code, I only changed the input. This time using real project management pages I already had bookmarked:

{
  "topic": "project management tools",
  "myPage": "https://www.learn-dev-tools.blog/best-legal-project-management-software/",
  "competitors": [
    "https://www.paymoapp.com/blog/project-management-software/",
    "https://project-management.com/top-10-project-management-software/",
    "https://zapier.com/blog/free-project-management-software"
  ]
}

Here's what the individual page extractions looked like:

And here's the comparison summary for this run — this is the output I actually use to plan my content updates:

This one was more telling. The mainstream tools were well covered on my end — monday.com, ClickUp, Trello, Asana, Wrike, Smartsheet, Basecamp all showed up in the shared list. But the competitorOnlyHeadings was long. Jira, Airtable, Zoho, Teamwork, Podio, Hive — tools I hadn't touched at all. The myPageOnlyHeadings also caught something I hadn't noticed: noise entries like "but what are" and "key features" were still leaking through, which meant the entity filtering still needed tuning for this type of content. The legal-specific tools I covered — Clio, Thomson Reuters — didn't appear anywhere in the competitor set, which made sense given the article's focus, but it also explained a big chunk of the gap.

Inspecting the Zapier page structure revealed exactly the kind of noise problem I mentioned earlier:

Extracting tools from comparison pages feels simple, I expected them to sit cleanly in H2 or H3 tags. But once I tried it across a few sites, that assumption broke. Some pages use H3 lists, others use H2 with long descriptions, and more complex ones don't expose tools as clear headings at all.

One problem was noise. The same heading level mixed tool names, scores, and editorial sections. If I extracted everything blindly, I ended up treating all of it as the same type of data. Another issue was that the DOM isn't just content, on modern pages, styled components wrap everything, so I started pulling CSS fragments or UI text alongside the actual tool names. The h3List for Zapier pages was polluted with text like .css-19a5n3-link{...} followed by the actual entity text.

And even when headings looked clean, their meaning wasn't consistent. A tool might be in H3 on one page and in H2 on another, while lower levels handled features or pricing. So relying on a fixed heading level worked sometimes, but quietly failed on others.

Enhancing the extraction

I needed to refine the results to stop getting polluted text like .css-19a5n3-link{...}. To fix this:

First, I added a text-cleaning layer to strip CSS fragments and normalize headings before comparison:

function cleanExtractedText(text) {
    return String(text || '')
        .replace(/\.css-[^{\s]+(?:\[[^\]]+\])?\{[^}]*\}/g, ' ')
        .replace(/@media[^{]*\{[^}]*\}/g, ' ')
        .replace(/[a-z-]+\s*:\s*[^;{}]+;/gi, ' ')
        .replace(/\u00a0/g, ' ')
        .replace(/\s+/g, ' ')
        .trim();
}

function normalizeHeading(text) {
    return cleanExtractedText(text).toLowerCase().replace(/\s+/g, ' ').trim();
}

function normalizeForComparison(text) {
    return cleanExtractedText(text)
        .toLowerCase()
        .replace(/\.com$/i, '')
        .replace(/[–—]/g, '-')
        .replace(/^\d+[\.]\s*/, '')
        .replace(/\s*\([^)]*\)\s*$/g, '')
        .replace(/[^\w\s:\-\.]/g, ' ')
        .replace(/\s+/g, ' ')
        .trim();
}

Second, I tightened entity detection instead of treating every heading as a tool. This removes scores, FAQs, pricing sections, action phrases, and other review scaffolding from the comparison layer:

function isEntityLike(text) {
    const value = canonicalizeEntity(text);
    if (!value) return false;
    if (entityBlocklist.has(value)) return false;
    if (isNumericLike(value)) return false;
    if (value.includes('{') || value.includes('}')) return false;
    if (isQuestionLike(text)) return false;
    if (startsWithAction(value)) return false;
    if (isDetailLike(value)) return false;

    const tokens = value.split(/\s+/).filter(Boolean);
    return tokens.length >= 1 && tokens.length <= 3;
}

function isMeaningfulHeading(text) {
    const value = canonicalizeEntity(text);
    if (!value) return false;
    if (isBoilerplateHeading(value)) return false;
    return true;
}

Third, I improved matching by canonicalizing entity labels and comparing them more flexibly. This is what merges things like monday work management into monday.com, or jira software cloud into jira, instead of treating them as separate tools:

function extractLabel(text) {
    const entity = extractEntityFromHeading(text);
    if (entity) return entity;

    const normalized = canonicalizeEntity(text);
    const tokens = getComparisonTokens(normalized);
    if (tokens.length === 0) return normalized;
    if (tokens.length <= 3) return tokens.join(' ');
    return tokens.slice(0, 3).join(' ');
}

function areHeadingsSimilar(a, b) {
    const na = canonicalizeEntity(a);
    const nb = canonicalizeEntity(b);

    if (!na || !nb) return false;
    if (na === nb) return true;
    if (na.includes(nb) || nb.includes(na)) return true;

    const aCandidates = buildHeadingCandidates(a);
    const bCandidates = buildHeadingCandidates(b);
    if (!aCandidates.length || !bCandidates.length) return false;

    const bSet = new Set(bCandidates);
    const bCompactSet = new Set(bCandidates.map(compact));

    for (const candidate of aCandidates) {
        if (bSet.has(candidate)) return true;
        if (bCompactSet.has(compact(candidate))) return true;
    }
    return false;
}

Finally, I slimmed the comparison summary by comparing only cleaned items that survive both isMeaningfulHeading() and isEntityLike():

function compareHeadings(myPageData, competitorsData) {
    const myRaw = getComparisonItems(myPageData).filter(isMeaningfulHeading).filter(isEntityLike);
    const compRaw = competitorsData.flatMap((page) =>
        getComparisonItems(page).filter(isMeaningfulHeading).filter(isEntityLike),
    );

    const sharedHeadings = [];
    const myPageOnlyHeadings = [];
    const competitorOnlyHeadings = [];

    for (const myItem of myRaw) {
        const hasMatch = compRaw.some((compItem) => areHeadingsSimilar(myItem, compItem));
        if (hasMatch) sharedHeadings.push(extractLabel(myItem));
        else myPageOnlyHeadings.push(extractLabel(myItem));
    }

    for (const compItem of compRaw) {
        const hasMatch = myRaw.some((myItem) => areHeadingsSimilar(compItem, myItem));
        if (!hasMatch) competitorOnlyHeadings.push(extractLabel(compItem));
    }

    return {
        sharedHeadings: uniqueList(sharedHeadings),
        myPageOnlyHeadings: uniqueList(myPageOnlyHeadings),
        competitorOnlyHeadings: uniqueList(competitorOnlyHeadings),
    };
}

After all three changes, the comparison output looked like this:

The difference is immediate: most of the noise is gone. The extracted lists now behave like actual entity sets, not raw headings. Shared tools are clean and consistent (clickup, asana, wrike), and both myPageOnlyHeadings and competitorOnlyHeadings are dominated by recognizable product names rather than mixed content. There are no scores, no editorial sections, and no CSS fragments.

The individual blog pages looked clean too, each tool clearly separated:

This output shows a clean separation between informational sections and the actual comparison block. I intentionally keep the full outline for each page instead of over-filtering it. The goal is not just extraction. Each individual page gives me a structural view of how competitors position their content: what sections they introduce, how they group tools, and what supporting topics they emphasize.

The comparison result serves a different purpose. It compresses everything into a single snapshot: what overlaps, what I'm missing, and what competitors are covering. The two outputs are complementary. The outline helps me understand how competitors structure their pages. The comparison helps me understand what I should add or remove.

Deploying the Actor on Apify

Once the crawler was working locally, I deployed it so it could run on demand or on a schedule. Since the project already follows the Actor structure, deployment is one command:

apify push

The push itself went fine. But the first run failed. I checked the logs and saw that my inputs weren't present — which made sense once I thought about it. On the Apify platform, each Actor run gets its own isolated storage: a fresh dataset, key-value store, and request queue managed by the platform. The local INPUT.json I had been using doesn't carry over after a push. I needed to define the input directly in the Console.

After a few seconds, the Actor appears in your Apify Console under Actors:

Open the Actor and set your input:

{
  "topic": "project management tools",
  "myPage": "https://www.learn-dev-tools.blog/best-legal-project-management-software/",
  "competitors": [
    "https://www.paymoapp.com/blog/project-management-software/",
    "https://project-management.com/top-10-project-management-software/",
    "https://zapier.com/blog/free-project-management-software"
  ]
}

Then click Save & Start to run the Actor. After the run completes, go to the Output tab to preview results:

You can also open the Dataset to inspect the full JSON output — the Apify Dataset storage docs explain how to export it in JSON, CSV, or Excel if you need it elsewhere.

Scheduling runs

I do competitor analysis monthly, so I set the Actor to run on a schedule instead of triggering it manually each time. Open your Actor in the Apify Console, click the three dots in the top-right corner, and select "Schedule Actor":

Then configure the frequency:

Running the crawler on a schedule turns it into a monitoring tool instead of a one-time analysis. Each run gives me an updated snapshot of new tools added by competitors, structural changes in their pages, and gaps that appear over time.

If you want to make your Actor public and earn from it, follow the Apify Actor publishing guide to list it on the Apify Store.

Enhancing capabilities

The current version is reliable for extracting and comparing tools across different page structures. A few improvements that naturally follow from this setup:

Handling dynamic pages: Some comparison pages rely heavily on JavaScript rendering. Switching to PlaywrightCrawler would allow extracting content that isn't present in the initial HTML.
Improving resilience against structural drift: As sites update their layouts, selectors and assumptions can break. Adding fallback strategies or scoring multiple candidate nodes would make extraction more robust over time.
Tracking changes over time: Instead of a one-time comparison, storing snapshots and detecting changes across runs would turn this into a proper competitor monitoring tool.

The full code is available in the GitHub repository - the entity detection logic is the part most worth adapting if your content niche differs from comparison articles.

Conclusion

When I ran this against my Windows OS alternatives article, the output was immediately useful. Several tools my competitors were covering didn't appear anywhere on my page. Pop!OS was one of them — it showed up across multiple competitor pages while being completely absent from mine. I went back, added it, restructured a few sections, and added some supporting content based on what the comparison revealed.

The key lesson wasn't about scraping. It was about the extraction layer. Raw headings are noisy and misleading. The real work is isolating actual content, stripping presentation artifacts, and making headings comparable across pages with completely different structures. Once that's solid, the comparison itself is straightforward.

If you want to take it further, the natural next steps are switching to PlaywrightCrawler for JavaScript-heavy pages, adding a scheduled diff to track changes over time, and extending the entity detection logic to cover more content niches. The GitHub repository includes all the supporting functions referenced in this article.

Localizing SaaS Applications: What Developers and Writers Get Wrong

Gun — Wed, 10 Jun 2026 14:09:03 +0000

Localizing SaaS Applications: What Developers and Writers Get Wrong

The demo goes live in Tokyo. Dates are formatted as MM/DD/YYYY. Currency shows a dollar sign. One nav label reads “Einstellungen,” a German string left over from a previous sprint, jammed against a truncated button that was clearly designed for shorter English text. The Japanese enterprise prospect says nothing. They just close the tab.

Nobody on the team saw it coming. The engineers shipped clean code, writers produced polished copy, translators did their jobs. And still, the product felt foreign, not because the words were wrong, but because the process was wrong.

This is what localization failure actually looks like in SaaS: not a dramatic mistranslation scandal, but a quiet accumulation of small decisions made by people who never thought about global users at all. A hardcoded date format here. An untranslatable idiom in the onboarding copy there. A button width that never had room to grow.

Localizing SaaS applications is one of the most misunderstood disciplines in product development. Most teams treat it as a translation project with a start date and an end date. It is neither. It is an architectural posture, a content discipline, and an ongoing product function, and the mistakes happen long before a single string ever reaches a linguist.

This article breaks down exactly where developers and writers get it wrong, why it matters more than most teams realize, and what better looks like at every layer.

First, Understand What You Are Actually Doing

Before diagnosing the mistakes, it helps to clarify three terms that get used interchangeably in sprint planning docs and product roadmaps. They are not the same thing.

Translation converts text from one language to another. It changes words.

Localization (l10n) adapts a product for a specific locale. It changes the experience: date formats, currency symbols, cultural references, legal copy, even which colors signal trust or danger in a given market. Microsoft’s localization guidance describes localization as the process of adapting a product to meet the language, cultural, and functional expectations of a specific market.

Internationalization (i18n) is the engineering work done before any translation begins. It designs software so it can support multiple locales without requiring structural code changes for each one. Microsoft defines software internationalization as the planning and design work that makes software adaptable across languages, regions, and cultures.

Confusing these three does not create a terminology problem, it creates an execution problem. Teams that skip straight to translation and wonder why scaling to a second language costs three times as much as the first are paying the price for skipping i18n. Crowdin estimates that attempting SaaS localization without a proper i18n foundation can increase costs by 3-5x. Delaying i18n post-launch also creates long-term rework because the foundation always determines the ceiling.

What Developers Get Wrong

Hardcoding User-Facing Strings

This is the most widespread and most expensive technical mistake in localizing SaaS applications. When developers embed text directly in component logic, every string becomes a surgical extraction problem later.

<button>Submit</button>

alert("User not found")

title="Settings"

Multiply that across a two-year-old codebase with four contributors and you are looking at weeks of archaeology before a translator sees a single word.

The fix is foundational: externalize all user-facing text into resource files such as .json, .po, or .xliff. Each string gets a key. Instead of "Welcome back!" hardcoded in a component, you use:

t('auth.welcomeBack')

The component no longer cares what language it renders in. This sounds obvious. It gets skipped constantly, especially on small strings and error messages, which are exactly the strings that erode trust when they appear in English in the middle of a localized UI.

This is also why standardized localization formats matter. Microsoft’s localization file-format guidance describes XLIFF as a format for exchanging localizable resources between tools, keeping translatable text separate from source files and allowing translators to work without touching the original code structure.

String Concatenation

This one is subtle and brutal. Developers write logic like this:

const message = "You have " + count + " items in your cart."

This works fine in English. It fails in languages where grammatical structure differs from English word order. German, Japanese, Arabic, Russian, and many other languages cannot always preserve meaning when translators receive sentence fragments instead of complete sentences. Concatenated strings hand translators fragments with no linguistic context. They are essentially untranslatable.

Microsoft’s message-formatting guidance makes the same point from a localization perspective: translators need enough control over placeholder order and placement because word order changes between languages.

The correct approach uses ICU MessageFormat or an equivalent, giving translators a complete sentence template with named placeholders:

{
  "cartItems": "You have {count, plural, one {# item} other {# items}} in your cart."
}

This also forces confrontation with the second concatenation trap: pluralization. English has two common forms. Other languages have different plural categories. The Unicode CLDR plural rules exist because languages do not share one universal singular/plural structure. ICU’s MessageFormat uses those plural rules to keep plural logic inside the translatable message instead of scattering it across application code.

The ICU plural category system gives translators the grammar rules they need:

zero
one
two
few
many
other

If pluralization logic is hardcoded for English’s binary singular/plural pattern, other languages break silently.

Ignoring Layout Flexibility

Translated text often expands or contracts, and W3C’s text size in translation guidance shows that shorter English strings can expand significantly when translated into other languages. Arabic and Hebrew also read right-to-left. A UI designed exclusively around English string lengths will break in multiple directions at once.

Buttons should not have fixed pixel widths. Navigation labels need room to breathe. Containers should be tested with pseudo-localization, a technique where placeholder text mimics the character width and encoding of target languages before real translation begins.

Catching a layout collapse in pseudo-localization takes minutes. Catching it in production, in a Japanese enterprise account, takes weeks of engineering time and an apology nobody wants to write.

RTL support deserves its own flag in the i18n roadmap. Microsoft’s software internationalization guidance explicitly flags bidirectional writing systems, such as Arabic and Hebrew, as something products should account for early.

CSS logical properties make this significantly less painful when built in from the start rather than retrofitted after the fact:

margin-inline-start: 1rem;
padding-inline-end: 1rem;

That is safer than hardcoding layout rules like:

margin-left: 1rem;
padding-right: 1rem;

Treating Locale as a Display-Layer Problem

Locale is not a stylesheet. It affects business logic.

The date 05/06/07 can mean different things depending on the locale. Number separators vary by country. Pricing display norms differ by market. Address field structures differ by country. Phone number formats differ by region.

None of this is a translation issue. All of it needs to be handled at the data and logic layer, using locale-aware libraries rather than format strings assembled at render time.

The JavaScript Intl API exists for this reason. It provides locale-sensitive formatting for dates, times, numbers, lists, and currencies, so applications do not have to rely on fragile manual formatting rules.

What Writers and Content Teams Get Wrong

Writing Source Copy That Cannot Be Localized

Technical writers and UX copywriters set the ceiling for every language that follows. If the English source is idiomatic, assumes Western context, or relies on wordplay, the localized versions will either sound awkward or cost a fortune to adapt properly.

Phrases like “let’s get the ball rolling,” “out of the box,” or “circle back” are invisible to native English speakers and genuinely difficult to translate for most linguists without losing meaning entirely. The same goes for culturally embedded metaphors, puns in feature names, and humor that depends on English phonetics.

The fix is straightforward: write source copy with localization in mind from the first draft. Use plain language. Favor direct, complete sentences over headline fragments. Fragments often drop grammatical cues that translators need to determine gender, tense, and case. Avoid idioms unless you are willing to budget for creative adaptation in every target locale.

Sending Strings Without Context

This is one of the most consistently cited mistakes among localization professionals. When a translator receives the string “Charge” with no additional information, they cannot tell if it means a financial transaction, a battery level, or a database write operation. The string “Check-in” could be a button, a status indicator, or a noun phrase.

Without a screenshot, a usage note, or a character limit, the translator is guessing, and a wrong guess on a billing CTA has direct revenue consequences.

Every string handed to a translation workflow should include:

where it appears in the UI
what action or state it describes
any character limit constraints
a screenshot if one exists

This also reduces retranslation cost. Microsoft’s localization overview notes that source errors, inconsistent terminology, and unclear materials can slow translation and create additional localization work after the source text changes.

Every major translation management system, including Lokalise, Phrase, and Crowdin, supports contextual metadata. The problem is not tooling availability. It is the discipline of populating that metadata before the handoff, not after the rework comes back.

Treating Localization as a One-Time Release Task

SaaS products ship continuously. Features are added weekly. Error messages are revised. Onboarding copy evolves with every A/B test. When localization is treated as a project milestone rather than a continuous workflow, translated versions fall behind the English source almost immediately.

Users in localized markets end up with a mixed-language interface: their language for established features, English for everything new. This is not a small cosmetic issue. It signals, loudly, that they are second-class users.

The answer is continuous localization: integrating translation workflows directly into the CI/CD pipeline so that new or updated strings trigger translation automatically when a developer pushes.

Git integrations in tools like Crowdin, Phrase, and Transifex make this operational rather than aspirational. Crowdin’s GitHub Action can upload source files, download translations, and create pull requests. Phrase and Transifex also document GitHub integrations for synchronizing localization files between repositories and translation workflows.

When the engineering release cycle and the localization cycle run in parallel, you get simultaneous global launches. When they are decoupled, you get a perpetually outdated product for your non-English users.

Where SEO Enters the Localization Workflow

Localized product content also needs localized search signals. If two pages target different language or regional versions of the same content, the implementation should help search engines understand the relationship between those versions.

For multilingual SaaS sites, this usually means using separate localized URLs, translated metadata, and correct hreflang annotations. Google’s documentation explains that hreflang helps it understand localized variations of the same page, so users can be served the version that best matches their language or region.

This matters because localization does not stop at the interface. Pricing pages, documentation, onboarding flows, help-center articles, and product-led SEO pages all become part of the localized user journey.

The Structural Problem Underneath All of It

Most of the mistakes above share a common origin: localization has no owner until it becomes a crisis.

In the design sprint, it is nobody’s job to verify that the component supports RTL. In the content review, it is nobody’s job to flag an untranslatable idiom. In the engineering standup, it is nobody’s job to confirm that a new error message has been externalized and keyed.

So these gaps accumulate quietly, sprint after sprint, until the Tokyo demo goes sideways and suddenly it is everyone’s problem at once.

The organizations that scale globally without painful rework have done one structural thing differently: they embedded localization ownership into product development before it became urgent. That means a localization lead with a seat at the product table, a shared glossary enforced at the TMS level, and a standing checklist: no new feature ships without an i18n review.

It Is a Systems Problem, Not a Language Problem

Localizing SaaS applications looks like a language challenge from the outside. From the inside, it is a systems design challenge with a language-shaped surface.

The translator cannot fix a hardcoded string. The writer cannot untangle a concatenated sentence after the fact. The product manager cannot retroactively build RTL support into a layout that was never designed for it.

Every one of these problems is seeded at the source in architecture decisions, content choices, and workflow assumptions made by people who were not thinking about global users at the time.

The good news is that none of these mistakes requires heroics to prevent. Externalize your strings early. Write source copy in plain, translatable language. Give translators context, not just words. Build localization into your release pipeline rather than scheduling it as a separate sprint. Assign ownership before the crisis arrives.

Do those things, and the translation itself, the part most people treat as the whole job, becomes the easy part.

Sources and Further Reading

How to Analyze a CSV File with Python and Pandas

Gun — Fri, 15 May 2026 18:17:23 +0000

CSV files show up in almost every business workflow. You may export orders from an ecommerce platform, download leads from a CRM, receive finance data from another team, or pull product usage data from an internal dashboard.
The challenge is that a raw CSV file rarely answers a question directly. It may contain duplicate rows, missing values, inconsistent column names, and dates stored in a format that makes time analysis difficult.
In this tutorial, you will work through a realistic sales analysis project. Imagine you received an ecommerce order export and need to answer one practical question:

What can this CSV tell us about revenue by product, category, country, and month?

You will start with a raw CSV file and finish with cleaned data, useful summaries, visualizations, and exported result files.
By the end, you will have:

Loaded a CSV file into Pandas
Inspected rows, columns, data types, and missing values
Cleaned column names, duplicates, missing values, and data types
Created a revenue column
Used filtering, sorting, and groupby() to answer business questions
Created a category bar chart and monthly line chart
Exported cleaned data and summary CSV files ## Prerequisites

You should know basic Python syntax, including variables, function calls, imports, and running scripts or notebooks. You do not need previous Pandas experience.
You can follow along in Jupyter Notebook, Google Colab, VS Code, or a regular Python script. A notebook gives you the easiest learning experience because you can inspect each result as you go.

Install Pandas and Matplotlib:

python -m pip install pandas matplotlib

If you use Conda, install from conda-forge:

conda install -c conda-forge pandas matplotlib

Now import the libraries:

import pandas as pd
import matplotlib.pyplot as plt

Check your Pandas version:

print(pd.__version__)

You may see output like this:

3.0.3

This tutorial uses modern Pandas practices. You will avoid chained assignment, and you will not use inplace=True as the default way to update data. Direct assignment usually reads better and works well with current Pandas behavior.

If Python raises ModuleNotFoundError: No module named 'pandas', your editor and terminal may use different Python environments. In VS Code, check the selected interpreter. In Jupyter, check the active kernel.

Create the Sales CSV File

You will use one dataset throughout this tutorial: a small ecommerce sales export. Keeping the dataset small lets you see every row, but the workflow matches what you would do with a larger real-world CSV. Either use a sale csv file you have, create a sample one or use this example to follow along

The dataset includes the columns you would expect in a sales export: order ID, order date, product, category, quantity, unit price, customer country, and payment method. It also includes a few issues on purpose. One row appears twice, one order has no date, one order has no category, and one order has no unit price.

Those issues are useful. They let you practice the kind of judgment you need when analyzing real CSV files.

Load the CSV File With Pandas

Load the file with pd.read_csv():

df = pd.read_csv(
    "sales_data.csv",
    parse_dates=["Order Date"]
)

print(df.head())

Expected output:

This code creates a DataFrame named df. A DataFrame is Pandas’ table structure: rows represent records, and columns represent fields.
The parse_dates=["Order Date"] argument matters because you will analyze monthly revenue later. If you load dates as plain text, you create extra work for yourself.

Understand File Paths
The path "sales_data.csv" is a relative path. It means Python should look for the file in the folder where your code runs.
If your file lives somewhere else, use an absolute path. On Windows, that might look like this:

df = pd.read_csv(
    r"C:\Users\YourName\Downloads\sales_data.csv",
    parse_dates=["Order Date"]
)

For this project, I would encourage you to use relative paths. They make your analysis easier to move between folders, machines, and teammates.

Useful **read_csv()** Options
You do not need many options for this sample file, but real CSV files often need extra instructions.

df = pd.read_csv(
    "sales_data.csv",
    sep=",",
    encoding="utf-8",
    parse_dates=["Order Date"],
    na_values=["", "NA", "N/A", "null"]
)

Here is the practical rule:
Use sep when the delimiter is not a comma. Use encoding when the file fails to decode. Use na_values when the source system uses custom labels for missing values. Use parse_dates when a column should behave like a date.

You will see usecols, dtype, and chunksize later when you adapt the workflow to larger files.
If you get FileNotFoundError, Pandas cannot find the file from the current working folder. Run print(Path.cwd()), move the CSV there, or use a full path.
If the file loads as one giant column, try a different delimiter such as sep=";" or sep="\t".
If Pandas raises UnicodeDecodeError, try encoding="latin1" or ask the data owner for the file encoding.

Inspect the Data Before You Clean It

Before you clean anything, inspect the dataset. This step protects you from making lazy assumptions.

Start with the first rows:

print(df.head())

Then check the last rows:

print(df.tail())

head() confirms that the file loaded as expected. tail() helps you catch issues near the bottom of the file. In this dataset, the last row repeats order 1008, which hints at a duplicate.

Expected result for tail

Check the size:

print(df.shape)

Expected output:

(16, 8)

The raw dataset has 16 rows and 8 columns.

Inspect the column names:

print(df.columns)

Expected output:

The names make sense to a human, but they are awkward in code because they contain spaces and mixed capitalization.

Now use info():

df.info()

Expected output will look similar to this:

This tells you where the main data quality issues are. You have missing values in Order Date, Category, and Unit Price.

Use describe() to inspect numeric columns:

print(df.describe())

Look for values that violate common business rules: negative quantities, zero prices, or extreme outliers. In this small file, the numeric ranges look reasonable.

Finally, check exact data types:

print(df.dtypes)

Your text-column dtypes may vary slightly by Pandas version.

Focus on the important question: can Pandas treat dates as dates and numbers as numbers?
If Order Date appears as object or str, Pandas did not parse it as a date. Check that parse_dates=["Order Date"] matches the column name exactly.

Clean the CSV Data

Now clean the file so you can trust the analysis. Cleaning does not mean forcing the data to look perfect. It means making clear, documented decisions that support your questions. We will start with the column.

Clean Column Names
Clean names early because every later step uses these names.

df.columns = (
    df.columns
    .str.strip()
    .str.lower()
    .str.replace(" ", "_")
)

print(df.columns)

Expected output:

Index(['order_id', 'order_date', 'product', 'category', 'quantity',
       'unit_price', 'customer_country', 'payment_method'],
      dtype='object')

Now your code can use df["unit_price"] instead of df["Unit Price"].
This may look cosmetic, but it is practical. Clean column names reduce typing errors and make your code easier to scan.

Count Missing Values
Count missing values after cleaning the column names:

print(df.isna().sum())

Expected output:

This output gives you three separate cleaning decisions. A missing date, missing category, and missing price do not mean the same thing. Treating them the same way would create weak analysis.

Remove Duplicate Rows
Check exact duplicates:

print(df.duplicated().sum())

Expected output:

Remove the duplicate row:

df = df.drop_duplicates()

print(df.shape)

Expected output:

(15, 8)

You now have 15 rows.
This is safe here because the duplicate row matches exactly. In a real dataset, duplicate IDs with different values require investigation, so do not delete those blindly.

Handle Missing Dates
We want monthly revenue, so rows without dates cannot support one of the main goals. Drop rows where order_date is missing:

df = df.dropna(subset=["order_date"])

print(df["order_date"].isna().sum())

Expected output:

This choice is specific to our sale file. If your analysis did not use dates, you might keep the row.

Fill Missing Categories
A missing category should not erase a valid sale. Keep the row and label the missing value as unknown:

df["category"] = df["category"].fillna("Unknown")

print(df["category"].value_counts(dropna=False))

Expected output should show one Unknown category.

This lets you include the revenue while still exposing the data-quality issue. That is usually better than hiding the row or pretending you know the category.

Fill Missing Unit Prices
A missing price affects revenue, so you need a reasonable rule. For this dataset, fill the missing price with the median price of the same product:

df["unit_price"] = df["unit_price"].fillna(
    df.groupby("product")["unit_price"].transform("median")
)

print(df["unit_price"].isna().sum())

Expected output:

The important method here is transform("median"). It calculates a median unit price for each product and returns values aligned to the original rows. That alignment lets Pandas fill the missing price with the right product-level median.

This beats a global median because product prices are not interchangeable. A monitor price and a cable price should not influence a missing notebook price.

Confirm and Fix Data Types
Check data types again:

print(df.dtypes)

Convert text columns to Pandas string type:

df = df.astype({
    "product": "string",
    "category": "string",
    "customer_country": "string",
    "payment_method": "string"
})

For this sample file, quantity and unit_price should already be numeric. For real files, convert numeric columns explicitly when needed:

df["quantity"] = pd.to_numeric(df["quantity"], errors="coerce")
df["unit_price"] = pd.to_numeric(df["unit_price"], errors="coerce")

Then check whether conversion introduced missing values:

print(df[["quantity", "unit_price"]].isna().sum())

Use errors="coerce" when you want invalid numeric text to become missing values. That makes the problem visible.

Create a Revenue Column
Create the metric you will use for analysis:

df["total_sales"] = df["quantity"] * df["unit_price"]

print(df[["order_id", "quantity", "unit_price", "total_sales"]].head())

Expected output:

At this point, the dataset has moved from raw order records to analysis-ready sales data.

Cleaning Checkpoint
Before analysis, run one quick checkpoint:

print(df.shape)
print(df.isna().sum())
print(df.dtypes)

You should see 14 rows after removing one duplicate and one row without a date. You should also see no missing values in the fields needed for this project.

This checkpoint separates cleaning from analysis. You do not want to discover data-quality problems halfway through a revenue summary.

Analyze Sales With `groupby()`

From now you can start answering business questions. The main tool in this section is groupby(). In plain English, groupby() lets you split rows into groups, calculate something for each group, and combine the results into a summary table.

For example, when you group by category and sum revenue, Pandas does this:

Splits rows into category groups.
Adds total_sales inside each category.
Returns one row per category.

Calculate Total Revenue
Start with the headline metric:

total_revenue = df["total_sales"].sum()

print(f"Total revenue: ${total_revenue:,.2f}")

Expected output:

Total revenue: $1,333.57

This is the total revenue after cleaning. It excludes the duplicate row and the row without an order date.

Find Revenue by Category
Group by category:

category_sales = (
    df.groupby("category", as_index=False)["total_sales"]
    .sum()
    .sort_values("total_sales", ascending=False)
)

print(category_sales)

Expected output:

as_index=False keeps category as a normal column instead of turning it into the index. For beginner analysis and CSV exports, that format is easier to read and reuse. Furniture leads revenue, even though it has fewer orders than some other categories. High unit prices can matter more than order count.

Find Top Products
Now summarize by product:

product_sales = (
    df.groupby("product", as_index=False)
    .agg(
        total_sales=("total_sales", "sum"),
        units_sold=("quantity", "sum"),
        orders=("order_id", "count")
    )
    .sort_values("total_sales", ascending=False)
)

print(product_sales)

Expected output:

This table is more useful than a single revenue ranking. It shows revenue, units sold, and order count together. The Monitor generated the most revenue. USB-C Cable sold the most units. Those are different types of performance, and a good analyst keeps them separate.

Find Revenue by Country
Group by customer country:

country_sales = (
    df.groupby("customer_country", as_index=False)["total_sales"]
    .sum()
    .sort_values("total_sales", ascending=False)
)

print(country_sales)

Expected output:

The United States contributes the most revenue in this sample. In a real business, this kind of table can support regional reporting, marketing decisions, or logistics planning.

Analyze Monthly Revenue
Create a month column from order_date:

df["order_month"] = df["order_date"].dt.to_period("M").astype("string")

The .dt accessor lets you work with datetime values. to_period("M") converts each date to its month, such as 2026-03. That gives you a clean monthly grouping key.
Now summarize revenue by month:

monthly_sales = (
    df.groupby("order_month", as_index=False)["total_sales"]
    .sum()
    .sort_values("order_month")
)

print(monthly_sales)

Expected output:

Revenue rises in March and April because the dataset includes higher-priced furniture orders in those months.
If .dt raises an error, order_date is not a datetime column. Convert it with:

df["order_date"] = pd.to_datetime(df["order_date"], errors="coerce")

Then check df["order_date"].isna().sum() before continuing.

Filter High-Value Orders
Use filtering to inspect the rows behind your summary tables.

high_value_orders = df[df["total_sales"] >= 100].sort_values(
    "total_sales",
    ascending=False
)

print(high_value_orders[["order_id", "product", "customer_country", "total_sales"]])

Expected output:

Only a few orders drive a large share of revenue. This is the kind of detail that summary tables can hide.
For multiple conditions, wrap each condition in parentheses:

us_high_value_orders = df[
    (df["customer_country"] == "United States") &
    (df["total_sales"] >= 100)
]

print(us_high_value_orders[["order_id", "product", "total_sales"]])

Use & for “and” and | for “or”. Python’s and and or do not work for Pandas Series filters.

Visualize the Results

You should not chart everything. Chart the results that become easier to understand visually.

Category Revenue Bar Chart
Use a bar chart for category comparison:

category_sales.plot(
    kind="bar",
    x="category",
    y="total_sales",
    legend=False,
    title="Revenue by Category"
)

plt.xlabel("Category")
plt.ylabel("Revenue")
plt.tight_layout()
plt.show()

The chart should show Furniture as the highest-revenue category. A stakeholder could understand that pattern faster from the chart than from the table.

Monthly Revenue Line Chart
Use a line chart for time trends:

monthly_sales.plot(
    kind="line",
    x="order_month",
    y="total_sales",
    marker="o",
    legend=False,
    title="Monthly Revenue"
)

plt.xlabel("Month")
plt.ylabel("Revenue")
plt.tight_layout()
plt.show()

The line should rise in March and April. In a larger dataset, this chart would help you identify seasonality, campaign effects, or unexpected drops.

If charts do not appear, make sure Matplotlib is installed and call plt.show(). In Jupyter notebooks, %matplotlib inline can help, but do not use that line in a regular Python script.

Working With Larger CSV Files

This tutorial uses a small file so you can focus on the workflow. Real CSV files may contain hundreds of thousands or millions of rows. You can still use Pandas, but you should load the data more carefully.
If you only need some columns, use usecols:

columns_to_load = [
    "Order ID",
    "Order Date",
    "Product",
    "Category",
    "Quantity",
    "Unit Price",
    "Customer Country"
]

large_df = pd.read_csv(
    "sales_data.csv",
    usecols=columns_to_load,
    parse_dates=["Order Date"]
)

This reduces memory use and keeps your analysis focused.
If you know the schema, set data types while loading:

large_df = pd.read_csv(
    "sales_data.csv",
    usecols=columns_to_load,
    parse_dates=["Order Date"],
    dtype={
        "Product": "string",
        "Category": "string",
        "Customer Country": "string",
        "Quantity": "int64",
        "Unit Price": "float64"
    }
)

If you are unsure about types, load a small sample first:

sample_df = pd.read_csv("sales_data.csv", nrows=1000)

print(sample_df.dtypes)

For very large files, read in chunks:

revenue_by_country = {}

for chunk in pd.read_csv(
    "sales_data.csv",
    parse_dates=["Order Date"],
    chunksize=5
):
    chunk.columns = (
        chunk.columns
        .str.strip()
        .str.lower()
        .str.replace(" ", "_")
    )

    chunk = chunk.dropna(subset=["order_date", "unit_price"])
    chunk["total_sales"] = chunk["quantity"] * chunk["unit_price"]

    chunk_summary = chunk.groupby("customer_country")["total_sales"].sum()

    for country, revenue in chunk_summary.items():
        revenue_by_country[country] = revenue_by_country.get(country, 0) + revenue

print(revenue_by_country)

The example uses chunksize=5 only because the sample file is tiny. For real files, try chunksize=50_000 or 100_000.

Pandas also supports dtype_backend="pyarrow":

df_arrow = pd.read_csv(
    "sales_data.csv",
    dtype_backend="pyarrow"
)

Treat this as optional. It can help some larger workflows, but it may require PyArrow and does not need to be your first optimization.
Pandas is enough for many CSV analysis tasks. If your data outgrows memory or you need fast SQL over local files, look at DuckDB. If you want a fast DataFrame library, consider Polars. If you need larger-than-memory workflows with familiar Pandas-like patterns, consider Dask. If many people need shared reporting, use a database.

Export Your Cleaned Data and Summaries

Now finish the project by saving your work.

Save the cleaned dataset:

df.to_csv("cleaned_sales_data.csv", index=False)

Save the summary tables:

category_sales.to_csv("category_sales.csv", index=False)
product_sales.to_csv("product_sales.csv", index=False)
country_sales.to_csv("country_sales.csv", index=False)
monthly_sales.to_csv("monthly_sales.csv", index=False)

Use index=False because the DataFrame index does not contain business information. If you omit it, Pandas writes the index to the file. When you load that file later, you may see an unwanted Unnamed: 0 column.

Confirm that your output files exist:

output_files = [
    "cleaned_sales_data.csv",
    "category_sales.csv",
    "product_sales.csv",
    "country_sales.csv",
    "monthly_sales.csv"
]

for file_name in output_files:
    print(file_name, Path(file_name).exists())

Expected output:

You now have files you can share, inspect in a spreadsheet, or use in another analysis step.
If Pandas raises a permission error, close the file in Excel or any other program that may have locked it.

Common Mistakes When Analyzing CSV Files

Most beginner CSV problems come from file setup, data types, and cleaning decisions.

If Pandas cannot find your file, check your working folder:

print(Path.cwd())

If the CSV loads as one giant column, specify the delimiter:

df = pd.read_csv("sales_data.csv", sep=";")

If the file fails with a decoding error, try another encoding:

df = pd.read_csv("sales_data.csv", encoding="latin1")

If dates do not work with .dt, parse them:

df["order_date"] = pd.to_datetime(df["order_date"], errors="coerce")

If numeric columns load as text, convert them:

df["unit_price"] = pd.to_numeric(df["unit_price"], errors="coerce")

If you need to update values conditionally, use .loc:

df.loc[df["category"].isna(), "category"] = "Unknown"

Avoid this chained-assignment pattern:

df\["category"\][df["category"].isna()] = "Unknown"

If your exported CSV contains an Unnamed: 0 column, export with:

df.to_csv("cleaned_sales_data.csv", index=False)

A good habit solves many of these mistakes, inspect before cleaning, and recheck after cleaning.

Best Practices Checklist

Here is a best practice checklist I have compiled and encourage you to use this checklist when you analyze your own CSV files:

Keep the raw file unchanged.
Inspect the dataset before cleaning it.
Clean column names early.
Parse dates before time-based analysis.
Treat missing values based on column meaning.
Check duplicates before removing them.
Convert data types deliberately.
Create calculated columns for the metrics you need.
Write analysis around specific questions.
Sort summary tables before interpreting them.
Use charts only when they clarify a pattern.
Save cleaned data separately.
Export with index=False unless the index matters. ## Practice Exercise

Extend the analysis with three questions. First, find revenue by payment method:

payment_sales = (
    df.groupby("payment_method", as_index=False)["total_sales"]
    .sum()
    .sort_values("total_sales", ascending=False)
)

print(payment_sales)

Next, find which country bought the most units:

country_units = (
    df.groupby("customer_country", as_index=False)["quantity"]
    .sum()
    .sort_values("quantity", ascending=False)
)

print(country_units)

Finally, calculate the share of revenue from Furniture:

furniture_revenue = df.loc[
    df["category"] == "Furniture",
    "total_sales"
].sum()

furniture_share = furniture_revenue / df["total_sales"].sum()

print(f"Furniture revenue share: {furniture_share:.1%}")

Export the payment summary:

payment_sales.to_csv("payment_sales.csv", index=False)

This exercise follows the same pattern as the main project: ask a question, group or filter the data, calculate the metric, sort the result, and save the output.

What Learned Today

You started with a raw ecommerce CSV and turned it into a practical sales analysis. You created sales_data.csv, loaded it into Pandas, inspected its structure, cleaned column names, removed a duplicate row, handled missing dates, categories, and prices, and created a total_sales metric.
Then you used that cleaned data to answer business questions about total revenue, category performance, product performance, country revenue, monthly trends, and high-value orders. You also created two charts and exported cleaned and summarized CSV files.
The final files are:

cleaned_sales_data.csv
category_sales.csv
product_sales.csv
country_sales.csv
monthly_sales.csv ## Conclusion

You analyzed a CSV file with Python and Pandas by following a repeatable workflow: load, inspect, clean, calculate, analyze, visualize, and export. Use the same structure with your own CSV files. Replace the sample file, update the column names, define your questions, and adapt the cleaning rules to your data. The specific dataset will change, but the habit stays the same: understand the file before you trust the numbers.

How to Integrate YouTube Video Player in a Flutter Application

Gun — Tue, 12 Mar 2024 14:11:20 +0000

YouTube is one of the world’s popular social media platforms for hosting and sharing videos. You can find a great list of music, movies, tutorials, documentaries and interviews in any domain there. Many enterprises, corporations and freelancers create and share videos on their various channels to enhance communication and provide a better user experience on the various services they offer. YouTube has become an indispensable social asset in the daily lives of many entrepreneurs and organizations.

Objectives

This guide will cover the necessary steps you need to follow to integrate YouTube into your Flutter application. In a nutshell, you will build a simple application like in the demo below.

Youtube Flutter Player Demo in Drive

Common Use Cases Where You Should Add YouTube Integration in Your Mobile App

Before diving into the main subject, it’s important to know when and where to integrate YouTube into your application. Some of the common use cases are:

Integrating Video Tutorials

One of the easiest ways to enhance user experience and improve engagement is by adding video tutorials from your channel or various subject matters that can interest your audience.

If you own a course or food application or a simple informational application, integrating YouTube can help users easily and efficiently get access to video content from your various channels that align with their interests.

Integrating in Movies Application

Adding movie trials or reviews via YouTube in your movie application allows users to get a preview of a specific movie and helps them decide whether to watch it or not. You can equally add behind-the-scene footage to spice up the app and encourage users to spend longer time on your application hence improving user engagement.

Informational oriented application

Informational-centered applications that provide articles, blog posts, and news about a variety of subjects can be enhanced by adding video-related content to improve user comprehension further.

Monetization

Implementing a YouTube player with ad support in your application provides a revenue stream for your application. For example, if you have a food recipe application, you can generate revenue by displaying YouTube videos with ads before, during or after the video.

Live Stream Events

You can embed YouTube live stream video using the YouTube LIVE API into your application easily for real-time interaction with your audience, product launch or Q&A sessions which can improve the kind of services you offer and user engagement.

Product Demonstrations

For educational applications or e-commerce applications, you can integrate YouTube videos to showcase the product features, the benefits of using it and real-life usage to the users in-app.

Travel

A mobile app that includes travel guides or travel-related content with embedded YouTube videos showcasing popular destinations, attractions, or travel tips.

For example, users can easily visualize popular spots instantly rather than navigating through a list of selected images.

Fitness and Music

In fitness applications, you can incorporate YouTube videos that demonstrate and guide users on how to perform certain movements.

Keep in mind that while integrating these YouTube features into your mobile application, it’s important to always ensure compliance with YouTube’s terms of service.

Integrating YouTube in a Flutter Application

In this section, we will work you through how to integrate a Youtube player into your Flutter application.

Prerequisites

YouTube Player Flutter
Basic Dart Knowledge

Creating a Flutter Application

Install Flutter, open your Android Studio editor and create a new Flutter project or open your terminal and run the following command to get started with a Flutter project.

flutter create example_project_youtube

example_project_youtube is the name of the project, and you can replace it with any name you want. Once the project is complete, choose an emulator or connect your phone and run the following command to launch it.

flutter run

Adding YouTube Package

To add the youTube_player_flutter package, open another terminal and run the following command:

flutter pub add youtube_player_flutter

youtube_player_flutter plugin for playing or streaming inline YouTube videos using the official iFrame player API. This plugin supports both Android and iOS.

This will add the youtube_player_flutter package in the dependencies section of your pubspec.yaml located at the root of your project.

dependencies:
  flutter:
    sdk: flutter

  # The following adds the Cupertino Icons font to your application.
  # Use with the CupertinoIcons class for iOS style icons.
  youtube_player_flutter: ^8.1.2

Now create two dart files in which one will contain the video JSON data model and the last will be the YouTube player page.

We also have the main.dart file which looks like this:

import 'package:flutter/material.dart';
import 'package:flutter_app_youtube/screens/YoutubeScreen.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.red),
        useMaterial3: true,
      ),
      home: const YouTubeScreen(),
    );
  }
}

Create a lib/model/VideoModel.dart and add the following code:

import 'dart:convert';

class VideoModel {
  int? id;
  String? name;
  String? url;

  VideoModel(this.id, this.name, this.url);

  VideoModel.fromJson(Map<String, dynamic> json) {
    id = json["id"];
    name = json['name'].toString();
    url = json['url'];
  }
}

Create YouTubeVideoScreen.dart

import 'package:flutter/material.dart';
import 'package:youtube_player_flutter/youtube_player_flutter.dart';

class YouTubeScreen extends StatefulWidget {

  const YouTubeScreen({Key? key}) : super(key: key);

  @override
  _YouTubeScreenState createState() => _YouTubeScreenState();
}

class _YouTubeScreenState extends State<YouTubeScreen> {
  String? videoId;

  @override
  void initState() {
    super.initState();
    videoId = 't31fj-0t3Dw';
  }

  @override
  Widget build(BuildContext context) {
    return YoutubePlayer(
      controller: YoutubePlayerController(
        initialVideoId: videoId!,
        flags: const YoutubePlayerFlags(
          autoPlay: true, 
          mute: false
        )
      )
    );
  }
}

A Youtube video url is generally in the form:

https://www.youtube.com/watch?v='Your video id here'

The v in the url contains the id of your video. So put this id in the videoId variable and test your application

Incorporating Features and Customizing YouTube Player

Show Video Progression Indicator

By default, the showVideoProgressIndicator is set to true, you can set it to false if you don’t want to see the video progression indicator.

showVideoProgressIndicator: false

Progress Indicator Color

Use the progressIndicatorColor attribute to change the color of the video progress indicator. For example, below we have changed the color to green:

progressIndicatorColor: Colors.green

Setting FullScreen Mode

To support Full screen you need to wrap the player in the YoutubePlayerBuilder:

YoutubePlayerBuilder(
  player: YoutubePlayer(
    controller: _controller,
  ),
  builder: (context, player){
    return Column(
      children: [
        player,
      ]
    );
  }
),

Adding Players Control

YoutubePlayerFlags allows you to define player flags. In the example below, we set the autoplay to false, disabled the audio by setting mute to true, enabled caption, and hide controls, looped the video and disabled video HD mode.

YoutubePlayerFlags(
  autoPlay: false,
  mute: false,
  enableCaption: true,
  loop: true,
  forceHD: false,
  hideControls: true
)

If you want to know more you can check the YoutublePlayerFlags Class and equally learn how to customize other features.

What’s Next

Conclusion

In this guide, we have learned how to integrate a YouTube video player into a Flutter application. By following the step-by-step guide and code examples provided, you can enhance your app's functionality and user experience by seamlessly incorporating YouTube videos. Remember to handle error cases gracefully and consider implementing additional features like Playback Speed and playlist integration to further enrich your app.

Flutter YouTube Player increases the productivity of your applicant by providing visual and dynamic content that makes your application both informative and engaging. You can add a YouTube video player in any application as you can see through the use cases provided earlier.

With the power of Flutter and YouTube integration, the possibilities are endless.

Happy coding!
Full GitHub Code of Tutorial.

Resources

https://pub.dev/packages/youtube_player_flutter

https://www.linkedin.com/pulse/why-considering-video-integration-mobile-apps-profitable-abbas/

Opensea vs Blur: Which Platform Suits Your Needs?

Gun — Tue, 12 Mar 2024 11:23:06 +0000

In the ever-evolving world of digital assets and non-fungible tokens (NFTs), choosing the right platform for buying, selling, or exploring NFTs can be a daunting task. Two of the leading platforms in this space are OpenSea and Blur. Each has its unique features, community, and approach to the NFT market. In this post, we’ll dive deep into the differences between OpenSea and Blur, helping you decide which platform best suits your needs as an NFT enthusiast, artist, or investor.

OpenSea: The Gateway to NFTs

OpenSea has established itself as the go-to marketplace for NFT transactions, often referred to as the eBay for digital assets. It’s designed to cater to a broad audience, from beginners in the NFT space to seasoned collectors and investors.

Key Features:

Diverse Marketplace: OpenSea boasts an expansive collection of NFTs across various categories, including art, domain names, virtual worlds, trading cards, and collectibles. This diversity makes it an attractive platform for users with varied interests.
User-Friendly Interface: The platform is known for its intuitive and easy-to-navigate interface, making it accessible for users of all levels of experience. Whether you’re creating, buying, or selling NFTs, the process is straightforward.
Cross-Blockchain Support: OpenSea supports multiple blockchains, including Ethereum, Polygon, and Klaytn. This cross-chain functionality allows users to explore a wider range of NFTs and engage with different blockchain communities.
Community and Resources: OpenSea offers extensive resources for new users, including guides, FAQs, and a supportive community. These resources are invaluable for those new to the NFT space.

Pros:

Wide range of NFTs
User-friendly for beginners
Strong community support

Cons:

Transaction fees can be high on certain blockchains
Some users have reported issues with customer service

Blur: The Professional’s NFT Marketplace

Blur positions itself as a platform for professional NFT traders and artists. It’s known for its advanced features and analytics, catering to users looking for a more data-driven approach to the NFT market.

Key Features:

Advanced Trading Tools: Blur offers sophisticated tools and analytics for users to track the market, analyze trends, and make informed decisions. This is particularly beneficial for professional traders and investors.
Batch Buying and Selling: The platform allows users to buy or sell multiple NFTs in a single transaction, streamlining the process and saving on transaction fees.
Rewards System: Blur incentivizes platform activity through a rewards system, offering BLUR tokens for actions like listing NFTs and participating in auctions. This can be particularly attractive for active traders and sellers.
Focus on Speed and Efficiency: The platform is optimized for speed, aiming to provide a seamless and efficient experience for high-frequency traders.

Pros:

Advanced tools and analytics
Incentivized participation
Efficient batch transactions

Cons:

Might be overwhelming for beginners
More focused on trading than the community aspect

Comparing OpenSea and Blur

When deciding between OpenSea and Blur, consider your objectives and preferences in the NFT space.

For Beginners and Enthusiasts:

If you’re new to NFTs or looking for a broad marketplace with diverse offerings, OpenSea is likely the better choice. Its user-friendly interface, extensive resources, and supportive community make it an ideal starting point for exploring the world of NFTs.

For Artists:

Artists looking to showcase their work might find OpenSea more accommodating due to its larger audience and the diversity of its user base. However, Blur’s advanced tools and analytics could also appeal to artists interested in market trends and the trading aspect of their work.

For Professional Traders and Investors:

For those with experience in the NFT market, particularly traders and investors seeking advanced tools and analytics, Blur stands out. Its focus on speed, efficiency, and the rewards system makes it a compelling option for users looking to maximize their engagement and returns.

Community vs. Trading Focus:

OpenSea fosters a broader community of NFT enthusiasts, making it a more suitable platform for users interested in the social and discovery aspects of NFTs. On the other hand, Blur appeals to users with a strong focus on the trading and investment side, offering tools and features that cater to this demographic.

Conclusion

Choosing between OpenSea and Blur ultimately depends on your specific needs, level of expertise, and interests within the NFT space. OpenSea offers a welcoming environment for newcomers and a diverse marketplace for collectors and artists, emphasizing community and accessibility. Blur, meanwhile, caters to the more professional segment of the market, providing advanced tools and analytics for serious traders and investors.

Before making your decision, consider what you value most in an NFT platform — whether it’s the community, diversity of assets, trading

How to Build an Electronic Commerce Store with Medusajs

Gun — Wed, 25 Oct 2023 12:55:57 +0000

The demand and supply of goods and services keep evolving daily. Businesses need to keep an eye on these evolutions to adopt the right ecommerce platform to distribute their goods and services to various end users.

Headless commerce is becoming increasingly popular because of its adaptability and scalability. A great option for constructing a headless commerce store is Medusa, an open source and scalable ecommerce engine. Next.js offers a robust framework for building storefronts.

With the help of Medusa and Next.js, you can develop a powerful and scalable online store that is tailored to the particular requirements of your company or business. Regardless of your experience as a developer or online retailer, this tutorial will guide you on building and customizing an electronic store.

Here’s a demo of the application with Medusa and Next.js by following this tutorial:

demo medusa electronic store.mp4

What Will You Learn?

Set up a Storefront with Medusa’s Next.js default starter template.
Add product using the admin dashboard.
Display products in your storefront.
Customize your storefront.
Add a Search option to your store.
Add a Payment option to your store.

You can find the code for this tutorial in this GitHub Repository.

What is Next.js?

Next.js is an open-source React framework for building user-friendly web applications. React is a JavaScript library for building interactive user interfaces. Next.js enables server-side rendering and requires minimal or no configuration.

Medusa offers two storefront starters: Next.js and Gatsby. It's easy to install them with the CLI command. Medusa Next.js storefront has many ecommerce pre-build features like a shopping cart, product display, payment processing, and more.

What is Medusa?

Medusa is an open-source digital commerce infrastructure built with Node.js and provides many ecommerce features such as RMA flows, product and collection management, order management, customization, and more.

These are some features that set Medusa apart from other ecommerce platforms. Medusa also offers a great developer experience, allowing developers to create amazing and scalable stores with minimal effort.

Medusa's headless architecture enables you to build your store with the framework or language of your choice. There are no constraints, as you can use Medusa's API to connect the Medusa admin to the storefront to perform actions like the product, customer, order, payment management, and many more.

Creating your Electronic Commerce Platform

This section highlights the steps to build your electronic store with Next.js and Medusa.

Prerequisites

Before you begin, make sure you have the following:

Nodejs version 14 or later
Git
Yarn or Npm(This tutorial uses Yarn)
A code editor like VSCode
An Algolia account
A Stripe account
S3 for file upload service

You will find all the resources used in this tutorial, such as icons and images in the Git repository.

How to Set Up the Medusa Server for the Electronic Store

If you have everything installed, follow these steps to set up your Medusa project.

Install the Medusa CLI tool with the following command:

yarn global add @medusajs/medusa-cli

Create your Medusa application with this command:

yarn create medusa-app

Upon executing, this command will ask you where you which to install your project. Enter a name there; in this tutorial, it is ElectronicStore. Then, press enter. For this tutorial, choose the Medusa-starter-default for the backend and the Next.js starter template for the storefront.

Normally you should have the same information as the screenshot below.

![How to Build an Electronic Commerce Store with Medusa and Nextjs]https://www.learn-dev-tools.blog/wp-content/uploads/2023/03/starter-1024x302.png

Upon the execution of this command, Medusa will create three folders in the ElectronicStore: storefront, admin, and backend.

To start each part of the application, open the three command line/terminal tabs and run the following command with respect to each folder:

# Medusa server
cd ElectronStore/backend
yarn start

# Admin
cd ElectronStore/admin
yarn start

# Storefront
cd ElectronStore/storefront
yarn dev

After executing those commands, visit localhost:8000 to view your storefront.

Similarly, visit your admin dashboard by opening your browser on localhost:7000. 7000 is the default admin port.

!https://www.learn-dev-tools.blog/wp-content/uploads/2023/03/admin-1024x552.png

The next step consists of styling your storefront. This tutorial uses Tailwind CSS very useful for building modern websites. Note that you can equally set up your Medusa admin, Medusa storefront, and Medusa Backend separately.

Styling the Electronic Commerce Storefront

This section shows how to style your storefront using Tailwind CSS. With create-medusa-app, the Next.js starter template already contains Tailwind. However, you need to configure the tailwind.config.js as follows:

/** @type {import('tailwindcss').Config} */
module.exports = {
  content: [
    "./app/**/*.{js,ts,jsx,tsx}",
    "./pages/**/*.{js,ts,jsx,tsx}",
    "./components/**/*.{js,ts,jsx,tsx}",

    // Or if using `src` directory:
    "./src/**/*.{js,ts,jsx,tsx}",
  ],
  theme: {
    extend: {},
  },
  plugins: [],
}

Now that you have successfully added Tailwind to your project, you must customize your storefront.

Customizing the Storefront

Start by changing the style of the header storefront/src/module/layout/templates/nav/index.tsx with the code below:

const Nav = () => {
  const { pathname } = useRouter()
  const [isHome, setIsHome] = useState(false)
  useEffect(() => {
    pathname === "/" ? setIsHome(true) : setIsHome(false)
  }, [pathname])

  const { toggle } = useMobileMenu()

  return (
    <div
      className={clsx("sticky top-0 inset-x-0 z-50 group", {
        "!fixed": isHome,
      })}
    >
      <header className="relative h-16 px-8 mx-auto transition-colors bg-white border-b border-transparent duration-200 group-hover:bg-white group-hover:border-gray-200 border-b-[#f1f1f1]">
        <nav
          className={clsx(
            "text-gray-900 flex items-center justify-between w-full h-full text-small-regular transition-colors duration-200"
          )}
        >
          <div className="flex-1 basis-0 h-full flex items-center">
            <div className="block small:hidden">
              <Hamburger setOpen={toggle} />
            </div>
            <div className="hidden small:block h-full">
              <DropdownMenu />
            </div>
          </div>

          <div className="flex items-center h-full">
            <Link href="/">
              <a className="text-xl-semi uppercase">
                <img src="/logo.png" alt="" width={50} />
              </a>
            </Link>
          </div>

          <div className="flex items-center gap-x-6 h-full flex-1 basis-0 justify-end">
            <div className="hidden small:flex items-center gap-x-6 h-full">
              {process.env.FEATURE_SEARCH_ENABLED && <DesktopSearchModal />}
              <Link href="/account">
                <a>Account</a>
              </Link>
            </div>
            <CartDropdown />
          </div>
        </nav>
        <MobileMenu />
      </header>
    </div>
  )
}

export default Nav

This code above changes the navbar by adding a border and logo.

To change the banner image, locate your storefront/src/modules/home/components/hero/index.tsx, which is the hero section and replace it with the code below:

const Hero = () => {
  return (
    <div className="h-[90vh] w-full relative">
      <div className="text-white absolute inset-0 z-10 flex flex-col justify-center items-center text-center small:text-left small:justify-end small:items-start small:p-32">
        <h1 className="text-2xl-semi mb-4 drop-shadow-md shadow-black">
          Hi 👋 welcome to my electronic shop
        </h1>
        <p className="text-base-regular max-w-[32rem] mb-6 drop-shadow-md shadow-black">
          The best electronic devices to help you in your daily tasks both in
          the professional and personal life.
        </p>
        <UnderlineLink href="/store">Explore products</UnderlineLink>
      </div>
      <div className="bg-white h-[90vh] w-full">
        The best electronic devices to help you in your daily tasks both
        in the professional and personal life.
      </div>
      <Image
        src="/hero2.jpg"
        layout="fill"
        loading="eager"
        priority={true}
        quality={90}
        objectFit="cover"
        alt="computer"
        className="absolute inset-0"
        draggable="false"
      />
      <div className="bg-black h-[90vh] w-full absolute top-0 opacity-50"></div>
    </div>
  )
}

export default Hero

This code block adds a banner image and text to the hero section.

Next, change how you display feature products in the home section. storefront/src/module/home/components/featured-products/index.tsx:

const FeaturedProducts = () => {
...
  return (
   ...
        <div className="flex flex-col items-center text-center mb-16">
          <span className="text-base-regular text-gray-600 mb-6">
            Latest products
          </span>
          <p className="text-2xl-regular text-gray-900 max-w-lg mb-4">
            Our newest electronic gadgets to make your life smooth.
          </p>
          <UnderlineLink href="/store">Explore products</UnderlineLink>
        </div>
       ...
  )
}

...

The code above changes the text of feature products of your store.

Change the section just before the footer storefront/src/modules/layout/components/footer-cta/index.tsx by adding the following code:

const FooterCTA = () => {
  return (
    <div className="bg-gray-100 w-full">
      <div className="content-container flex flex-col-reverse gap-y-8 small:flex-row small:items-center justify-between py-16 relative">
        <div>
          <h3 className="text-2xl-semi">Check out the lastest gadgets</h3>
          <div className="mt-6">
            <UnderlineLink href="/store">Explore products</UnderlineLink>
          </div>
        </div>

        <div className="relative w-full aspect-square small:w-[35%] small:aspect-[28/36]">
          <Image
            src="/hero3.jpg"
            alt=""
            layout="fill"
            objectFit="cover"
            className="absolute inset-0"
          />
        </div>
      </div>
    </div>
  )
}

export default FooterCTA

Here you are changing the default text as well as the default image.

Now move to the footer file storefront/src/modules/layout/components/footer-nav/index.tsx and replace it with the following code:

const FooterNav = () => {
  const { collections } = useCollections()

  return (
    <div className="content-container flex flex-col gap-y-8 pt-16 pb-8">
      <div className="flex flex-col gap-y-6 xsmall:flex-row items-start justify-between">
        <div>
          <Link href="/">
            <a className="text-xl-semi uppercase">
              <img src="/logo.png" alt="" width={50} />
            </a>
          </Link>
          <p className="py-5 text-sm text-[#999]">
            Get the best electronics from the best place
          </p>
          <div className="flex flex-col-reverse gap-y-0 justify-center xsmall:items-center xsmall:flex-row xsmall:justify-between">
            <span className="text-xsmall-regular text-gray-500">
              © Copyright 2023 ES store
            </span>
            <div className="min-w-[316px] flex xsmall:justify-end">
              <CountrySelect />
            </div>
          </div>
        </div>
        <div className="text-small-regular grid grid-cols-3 gap-x-16">
          <div className="flex flex-col gap-y-2">
            <span className="text-base-semi">Collections</span>
            <ul
              className={clsx("grid grid-cols-1 gap-y-2", {
                "grid-cols-2": (collections?.length || 0) > 4,
              })}
            >
              {collections?.map((c) => (
                <li key={c.id}>
                  <Link href={`/collections/${c.id}`}>
                    <a>{c.title}</a>
                  </Link>
                </li>
              ))}
            </ul>
          </div>
        </div>
      </div>
    </div>
  )
}

export default FooterNav

This code snippet above adds new links and a logo in the footer. In the last part of the footer, change the background colour storefront/src/modules/layout/components/medusa-cta/index.tsx

const MedusaCTA = () => {
  return (
    <div className="py-4 flex justify-center items-center w-full bg-[#333]">
      <div className="content-container flex justify-center flex-1">
        <a href="https://www.medusajs.com" target="_blank" rel="noreferrer">
          <PoweredBy />
        </a>
      </div>
    </div>
  )
}

Head to storefront/src/pages/index.tsx to modify the meta information of the home page:

const Home: NextPageWithLayout = () => {
  return (
    <>
      <Head
        title="Home"
        description="Get the best electroics for your home and office from the best stores online with secure payment methods."
      />
      <Hero />
      <FeaturedProducts />
    </>
  )
}

By the end, you should have a store similar to the screenshot below:

!https://www.learn-dev-tools.blog/wp-content/uploads/2023/03/store1-1024x470.png

Adding Products in the Electronic Commerce Store

By default, Medusa comes with some products on the storefront. You need to add your products. Medusa commonly uses a file service plugin to add products to the admin dashboard.

Installing and Integrating a File Service Plugin (S3)

Simple Storage Service (S3) is a powerful open-source object storage suite available on any public and private cloud. Medusa uses file service plugins to host files such as images.

This tutorial will use AWS S3, but you can use other file services like Space and Minio. You need to have an AWS account and create a bucket if you have none. Equally, you need to create an access and secret key that you will use in the next section to build your store.

When you are done with that, install the S3 plugin in the backend with the command below:

yarn add medusa-file-s3

Then, open your backend/.env file and add the following:

S3_URL=<YOUR_BUCKET_URL>
S3_BUCKET=<YOUR_BUCKET_NAME>
S3_REGION=<YOUR_BUCKET_REGION>
S3_ACCESS_KEY_ID=<YOUR_ACCESS_KEY_ID>
S3_SECRET_ACCESS_KEY=<YOUR_SECRET_ACCESS_KEY>

<YOUR_BUCKET_URL> corresponds to the URL of your bucket it's generally in the form: http://<YOUR_BUCKET_NAME>.s3-website-<YOUR_BUCKET_REGION>.amazonaws.com
<YOUR_BUCKET_NAME>: The name of your S3 bucket
<YOUR_ACCESS_KEY_ID: The access key which was created earlier
<YOUR_SECRET_ACCESS_KEY>: The secret key created earlier

To complete the S3 integration, add the following configuration to the array of plugins in the backend/medusa-config.js file:

const plugins = [
  // ...
  {
     resolve: `medusa-file-s3`,
    options: {
      s3_url: process.env.S3_URL,
      bucket: process.env.S3_BUCKET,
      region: process.env.S3_REGION,
      access_key_id: process.env.S3_ACCESS_KEY_ID,
      secret_access_key: process.env.S3_SECRET_ACCESS_KEY,
    },
  },
]

Lastly, edit storefront/next.config.js file like this:

images: {
    domains: ["<YOUR_BUCKET_NAME>.s3.amazonaws.com"],
  },

Add the domain from where you are uploading your images. corresponds to the name of your bucket. Once you have finished setting up S3, you can add electronic products to your store.

Add Products with Medusa Admin

To add products to your store, head to the admin dashboard (localhost:7000). The default login credentials are admin@medusa-test.com and supersecret. The Medusa admin dashboard connects the Medusa server to help you to manage your store.

Once you logged in, you should have a similar interface as below. Here you can manage your products, orders, customer settings, and more.

!https://www.learn-dev-tools.blog/wp-content/uploads/2023/03/dash-1024x464.png

Head to the product page and delete all the default products by clicking on the three dots at the end and selecting delete.

!https://www.learn-dev-tools.blog/wp-content/uploads/2023/03/deleteprod-1024x176.png

After removing all the products, click on add new product button to add some electronic products to the ecommerce store.

!https://www.learn-dev-tools.blog/wp-content/uploads/2023/03/store3-1024x464.png

If you go to localhost:8000/store you will see your newly-added products.

!https://www.learn-dev-tools.blog/wp-content/uploads/2023/03/store2-1024x469.png

Integration

Now is the time to integrate the two main services: Search and Payment.

Algolia Integration

Algolia is an open-source UI search JavaScript library. It allows you to add advanced search functionalities to your store. Adding this search functionality to your store will greatly improve the user experience and optimize internal search in the electronic commerce store.

To add Algolia to your application, you need to possess an Algolia account. Upon creating your account, follow this documentation to create an Algolia application and then, get your Algolia Application ID, Admin API Key, and Search-Only API Key.

Next, install the Algolia plugin in your store with the following command:

yarn add medusa-plugin-algolia

Then add this environment variable to your Medusa backend:

ALGOLIA_APP_ID=<YOUR_APP_ID>
ALGOLIA_ADMIN_API_KEY=<YOUR_ADMIN_API_KEY>

<YOUR_APP_ID> and <YOUR_ADMIN_API_KEY> correspond to the Application ID and Admin API Key mentioned earlier. You can find them on the API Keys page under your Algolia account.

Add the following item into the plugins array in medusa-config.js:

const plugins = [
  // ...
  {
    resolve: `medusa-plugin-algolia`,
    options: {
      application_id: process.env.ALGOLIA_APP_ID,
      admin_api_key: process.env.ALGOLIA_ADMIN_API_KEY,
      settings: {
        products: {
          searchableAttributes: ["title", "description"],
          attributesToRetrieve: [
            "id",
            "title",
            "description",
            "handle",
            "thumbnail",
            "variants",
            "variant_sku",
            "options",
            "collection_title",
            "collection_handle",
            "images",
          ],
        },
      },
    },
  },
]

searchableAttributes are attributes in a product that are searchable while attributesToRetrieve are attributes to retrieve for each product result.

Now, add the search UI to the storefront so that users can effectively perform product research. Fortunately, Next.js storefront Algolia integration is available out-of-the-box. To get everything ready, make sure the search feature is set to true in the store.config.json:

 {
  "features": {
    "search": true
  }
}

Then add the environmental variables:

NEXT_PUBLIC_SEARCH_APP_ID=<YOUR_APP_ID>
NEXT_PUBLIC_SEARCH_API_KEY=<YOUR_SEARCH_API_KEY>
NEXT_PUBLIC_SEARCH_INDEX_NAME=products

<YOUR_APP_ID> corresponds to the Application ID.
<YOUR_SEARCH_API_KEY> corresponds to the Search-Only API Key. You can find this information in your Algolia API Keys section.

To complete this integration, change the code in src/lib/search-client.ts to the following:

import algoliasearch from "algoliasearch/lite"

const appId = process.env.NEXT_PUBLIC_SEARCH_APP_ID || ""

const apiKey =
  process.env.NEXT_PUBLIC_SEARCH_API_KEY || "test_key"

export const searchClient = algoliasearch(appId, apiKey)

export const SEARCH_INDEX_NAME =
  process.env.NEXT_PUBLIC_INDEX_NAME || "products"

If you run your storefront and backend, you will notice that the search feature is available.

!https://www.learn-dev-tools.blog/wp-content/uploads/2023/03/search-1024x553.png

Payment Integration with Stripe

This section will guide you through how to set up Stripe payment methods in your Medusa backend, admin, and storefront. Stripe is one of the simplest ways to accept online payments. It gives you the technical components needed to manage transactions safely. Other payment methods you can use with Medua are Paystack, Klarna, and Paypal.

To add Stripe to your store, you must possess a Stripe account. Like Algolia, you must retrieve your account's API Keys and secrets to connect Medusa to your Stripe account.

In the root directory of the Medusa backend, use the following command to install the Stripe plugin:

yarn add medusa-payment-stripe

Next, you need to add configurations to your stripe plugin. In medusa-config.js, add the following at the end of the plugins array:

const plugins = [
  // ...
  {
    resolve: `medusa-payment-stripe`,
    options: {
      api_key: process.env.STRIPE_API_KEY,
      webhook_secret: process.env.STRIPE_WEBHOOK_SECRET,
    },
  },
]

Head to the dashboard of your Stripe account to retrieve the API Key and secret key. Then, in your Medusa backend, create .env if it does not exist and add the Stripe key:

STRIPE_API_KEY=sk_...

Next, add Stripe’s webhook in the .env file. You can get it by heading to the Stripe dashboard and clicking Add an Endpoint. Medusa backend's endpoint, Stripe webhook, is {BACKEND_URL}/stripe/hooks.

Note: Add this endpoint to its field if you are in production, and replace {BACKEND_URL} with the URL of your backend. Add a description, select at least one action, and then click Add Endpoint. Once the Webhook is created, you’ll see "Signing secret" in the Webhook details. Reveals the secret key by clicking reveal it and copying it into your Medusa backend.

STRIPE_WEBHOOK_SECRET=whsec_...

The last part of Stripe integration consists of setting it up in the Medusa admin by adding a payment provider.

Go to Settings → Regions.
Select a region to edit.
Click on the icon at the top right of the first section on the right.
Click on Edit Region Details from the dropdown.
Under the provider's section, select the payment providers you want to add to the region. Here it's Stripe.
Unselect the payment providers you want to remove from the region.
Click Save.

Finally, in your storefront, add the following environment variable:

NEXT_PUBLIC_STRIPE_KEY=<YOUR_PUBLISHABLE_KEY>

Where <YOUR_PUBLISHABLE_KEY> corresponds to your Stripe Publishable Key.

If you run your Medusa storefront and backend, add products to your cart, and then proceed to checkout, you can now use Stripe as a payment method. Here is what the final result looks like:

!https://www.learn-dev-tools.blog/wp-content/uploads/2023/03/store4-1024x558.png

You could also check out this Stripe guide for more information regarding its integration

Testing the Store

The final step of this tutorial consists of testing the whole store. While the Medusa server is still running, restart your storefront.

Navigate to localhost:8000 to see the final electronic commerce store:

Click on the store item in the navigation bar to open the store:

Add some products to your cart:

!https://www.learn-dev-tools.blog/wp-content/uploads/2023/03/store8-1024x467.png

Checkout:

View your order:

!https://www.learn-dev-tools.blog/wp-content/uploads/2023/03/store10-1024x465.png

Conclusion

In this tutorial, you learned how to build a headless electronic commerce platform with the Medusa engine, using the Next.js Storefront and integrating services like search and payment using Algolia and Stripe.

However, you can add many other functionalities to this electronic commerce store. Some include gift cards, tax management, custom shipping methods, and Notifications.

Go to the Medusa documentation for more details regarding these functionalities and services.

This article was originally published on the Learn Dev Tools Blog

7 Useful Mobile Applications to Improve Your Productivity as a Developer

Gun — Tue, 04 Jul 2023 20:37:08 +0000

Today many things that were usually done on a desktop, can now be performed on your smartphone thanks to the evolution of Mobile phones. Developers must be always on the move in today's fast-paced world, working on their projects and remaining productive. Mobile apps, which provide ease and flexibility, have become an essential element of a developer's arsenal. Having the appropriate mobile apps may dramatically enhance your productivity, whether you're coding on the move or managing your projects remotely. In this article, we'll look at the best mobile apps that every developer should use.

1. Code from Anywhere with Replit

Coding from anywhere and doing everything you'd normally do on a desktop, such as coding the complete project, sharing, and hosting, are all possible. Everything is handled via your phone. Replit comes with everything you need to get started, including a CPU, storage, and RAM. You can interact with the terminal, use a file system, and do other things. Replit is available for Android and iOS systems

2. Improve Your Productivity with Macrodroid

One feature that Android consumers like is freedom. They are free to do whatever they choose. You can do even more using Macrodroid. It is one of the best Android device automation tools. You can auto-skip YouTube advertising, auto-swipe in TikTok, do something when something happens, and so on. The app is readily available for Android users only

3. Test your APIs directly with Your Mobile Phone using API Tester

API Tester is a robust tool for testing and debugging APIs from mobile devices. It has most of the functionalities of a typical desktop API testing program. You can test any API, including REST, GraphQL, WebSocket, and SOAP. It uses cURL or files from your device to import requests and collections. You can also run all queries simultaneously, save variables for later use, and integrate with other Widgets. API Tester is available on both AppStore and PlayStore

Share your work with friends, coworkers, or team members while maintaining control over viewing and editing rights. Collaborate whether you're at home, in your workplace, or on the other side of the world. With a single click, Mindly can convert your well-structured Word, HTML, or Markdown document into a creative and entertaining mind map. Anytime you add, delete, or relocate nodes, your map automatically updates and preserves its layout. You can even import and export to or from your Dropbox account.

The app is readily available on AppStore and PlayStore

5. Avoid Painless Configurations with Expo Go

Expo Go will be extremely beneficial for React Native developers or anyone on their way to want to learn React Native. Rather than installing and configuring Android Studio locally for development. Simply use Expo Go to see real-time changes and easily share your creation with everyone. Create a react-native project with appropriate configurations, then scan the QR code from the console. The Expo Go smartphone app will provide access to the project. All your changes will be directly reflected in the app. You can download the app on PlayStore or AppStore

6. Stay up to date with DevBytes

As a developer, you must constantly stay up to date on the latest technological developments. However, most of you do not have time to investigate and read lengthy articles. DevBytes explores, resumes and presents popular computer programming news. Not only can you obtain news, but you can also learn new coding ideas with explanations and code samples, find career possibilities, and participate anonymously in public polls to express your opinions. The application is only available on PlayStore.

7. Plan Easily with Planio

Planio implements scrum and agile methods. On the Agile Kanban-style board, you can plan sprints and track progress. However, more standard project management tools such as milestones and the Gantt chart can also be used. This is useful when you cannot manage everything using agile methodologies. As your team completes milestones, they'll start coming up with brilliant ideas. You want to debate them, evaluate their merits, and record your team's findings. Planio also, allows you to construct your wiki, discuss ideas in a forum atmosphere, or simply leave comments on, well, just about anything. Work from anywhere at any time.

Conclusion

Mobile apps have transformed the way developers work and increased their productivity. Developers can code, collaborate, manage projects, and stay connected right from their mobile apps. Their simplicity and flexibility can enable developers to be productive even while they are on the go. Including these top mobile apps in their toolset will certainly improve the development process and yield better results.

How to Localize Your Vue Application with Tolgee?

Gun — Thu, 29 Jun 2023 12:34:45 +0000

Nowadays, providing solutions to specific problems identified in a domain has fueled the creation and growth of many companies and startups. But one problem arises which is how to market the product in various places given that not everyone does not have the same background. Even though English is one of the most used languages, especially in the professional domain, this does not exclude the other part of the population that uses other languages. To build an application or solution for a specific area, you need to assure that your solution will efficiently communicate with the target audience. Software localization is the process of adapting a product or a service offered by the software to meet the needs of a desired culture, population or language.

In this article, you will learn how to localize your Vue application in various languages with Tolgee an open-source tool. But before that let’s have an overview of what Tolgee and Vuejs are.

What is Tolgee?

Tolgee is an open-source platform that provides a user-friendly interface for organizing translations for developers and translators. It facilitates the translation process by providing a centralized site for all translation duties, such as managing translation files, translating text, and integrating with popular development tools such as Nextjs, Gatsby or Angular. Tolgee also provides a number of tools to aid collaborative translation operations, including translation memory. Tolgee is an all-in-one solution for project management and optimizing multilingual content distribution.

What is Vue.js?

Vue.js is a JavaScript framework used for creating user interfaces, PWA and single-page apps. It is intended to be adopted in stages and can also serve as a web application framework capable of powering complex single-page applications. Vue.js is well-known for its ease of use and simplicity, making it a popular choice among developers for creating scalable and performant web apps.

How to Integrate Tolgee into a Vue Application

This selection highlights a step-by-step approach to integrating Togee into a Vue application.

Step 1: Install Tolgee

You can either create a Tolgee project via the Tolgee Cloud Platform or self-host it. In this tutorial, we will use the hosted version of Tolgee. However, you can host the server on your own via Docker. If you don’t have Docker installed use this Docker quick guide to get started

It is recommended to run it in a single container.

docker run -v tolgee_data:/data/ -p 8085:8080 tolgee/tolgee

Then follow this guide to configure your Tolgee project.

Step 2: Create a Project

Once everything is set up, log into your account and create a new project. Give a name to your project and add the languages you wish your app to use. In this tutorial, the app will use three languages: English, French and Spanish

Step 3: Generate API Key

Still, in your Tolgee dashboard, navigate to integrate; the last element in the left menu and select Vue among the list of app integrations

Then in the select input, click on Create new to create a new API Key.

Name your API key and select the period of time you wish to use it and click on Save.

This will generate a first-time-only token that you need to save somewhere on your PC because you will use it later.

Step 4: Add Tolgee to Your Vue application

Navigate to your desired directory and run the following command :

npm init vue@latest

You will be prompted to provide your project’s name and other information.

If you already have a project setup, you can skip this step.

Vue.js - The Progressive JavaScript Framework
√ Project name: ... vue-tolgee
√ Add TypeScript? ... No / Yes
√ Add JSX Support? ... No / Yes
√ Add Vue Router for Single Page Application development? ... No / Yes
√ Add Pinia for state management? ... No / Yes
√ Add Vitest for Unit Testing? ... No / Yes
√ Add an End-to-End Testing Solution? » No
√ Add ESLint for code quality? ... No / Yes
√ Add Prettier for code formatting? ... No / Yes

Once the command is executed, navigate to the project’s root directory and run npm install, then npm run dev to start the app.

If your application does not automatically open, type [localhost:5173](localhost:5173)`` in your browser to visualise your freshly created application.

If your project is a Vue 3 Typescript project create shims-vue.d.ts file and add the following code:

/* eslint-disable */
declare module '*.vue' {
  import type { DefineComponent } from 'vue';
  const component: DefineComponent<{}, {}, any>;
  export default component;
}

This will allow you to import vue components.

Step 5: Install Tolgee Package

Now use the command below to install Tolgee.

cd vue-tolgee
npm install @tolgee/vue

Step 6: Add Environment Variable:

Create env.development.local file if you don’t have one at the root of your project and paste the following code

VUE_APP_TOLGEE_API_URL=<host>
VUE_APP_TOLGEE_API_KEY=<Only new key can be revealed>

VUE_APP_TOLGEE_API_URL is where your Tolgee server is hosted

VUE_APP_TOLGEE_API_KEY is your API key. If somehow you lost the API key you generated earlier, you can regenerate a new one.

Click on your profile picture at the top right corner of the dashboard

Then Select Project API Keys. In the new window that opens, either you add a new API key or you generate a new one. Make sure to save the API key somewhere this time in case you failed to do it previously.

Once your API key is ready, you can now add it to your env file.

Step 7: Initialize Tolgee

Update your main.ts found at the root of your project with the following code:

import './assets/main.css';
import { createApp } from 'vue';
import App from './App.vue';
import {
  BackendFetch,
  DevTools,
  Tolgee,
  FormatSimple,
  VueTolgee,
} from '@tolgee/vue';

const tolgee = Tolgee()
  .use(DevTools())
  .use(FormatSimple())
  .use(BackendFetch())
  .init({
    language: 'en',
    apiUrl: import.meta.env.VITE_TOLGEE_API_URL,
    apiKey: import.meta.env.VITE_TOLGEE_API_KEY,
  });
const app = createApp(App);
app.use(VueTolgee, { tolgee });
app.mount('#app');

Then wrap your code in src/app.vue in TolgeeProvider tag like below:

<template>
  <TolgeeProvider>
    <header>
      <img
        alt="Vue logo"
        class="logo"
        src="./assets/logo.svg"
        width="125"
        height="125"
      />
      <div class="wrapper">
        <HelloWorld msg="You did it!" />
      </div>
    </header>
    <main>
      <TheWelcome />
    </main>
  </TolgeeProvider>
</template>

Step 8: Add Translations

Now head to your Tolgee server and add some translations. In this tutorial, you will be translating the default Vue 3 starting application so for each text, add a keyname, and add the default English text. Make sure to conventionally name your translations.

Then click on the French and Spanish input to select a translation from the machine-generated translations that best describes the text. You can adjust if you feel that the text does not fit its context.

Repeat this process until all translations are added. In the end, you should see the list of translations below.

Step 9: Create a Select Component

The select component will help you easily switch from one language to another. In your src/components created selector.vue file and add the following code:

<script setup>
import { useTolgee } from '@tolgee/vue'
const tolgee = useTolgee(['language'])
const changeLanguage = (e) => {
  tolgee.value.changeLanguage(e.target.value)
}
</script>
<template>
  <select :value="tolgee.getLanguage()" v-on:change="changeLanguage" class="selector">
    <option value="en">🇬🇧 English</option>
    <option value="fr">🇫🇷 Français</option>
    <option value="es">🇪🇸 Español</option>
  </select>
</template>

Now let’s give some style to the select tag with the following code in src/assets.main.css:

.selector {
  display: block;
  text-align: center;
  width: 80%;
  padding: 10px;
  border-radius: 5px;
  font-size: 18px;
  border: none;
  background: rgba(0, 255, 255, 0.51);
  -webkit-appearance: none;
  -moz-appearance: none;
  text-indent: 1px;
  text-overflow: '';
  cursor: pointer;
  margin-left: 10px;

Step 10: Add Translation Keynames

This is the last step which consists of adding translation keynames. A typical translation looks like this:

import { T } from '@tolgee/vue';

<T keyName="documentation" defaultValue="Documentation" />;

So in your src/components/TheWelcome.vue replace your code with the following:

And src/components/HelloWorld.vue add:

<script setup lang="ts">
import { T } from '@tolgee/vue'
...
</script>

<template>
  <div class="greetings">
   ...
    <h3>
      <T keyName="success" defaultValue="You've successfully created a project with Vite + Vue 3" />
    </h3>
  </div>
</template>

Finally, update your App.vue file with the code below:

In the code block above, we have updated our components imports and added the Selector component we created earlier.

But there is one last thing we need to do, which is to add our translation files to the Vue project.

In your Tolgee dashboard, click on export in the left menu, then select the languages you wish to use and click on export.

Create i18n folder in your Vue application public folder and add the extracted files

utilis/i18n/en.json

{
  "documentation": "Documentation",
  "documentation_desc": "Vue’s official documentation provides you with all information you need to get started.",
  "tooling": "Tooling",
  "tooling_desc": "This project is served and bundled with Vite. The recommended IDE setup is VSCode + Volar. If you need to test your components and web pages, check out Cypress and Cypress Component Testing. More instructions are available in README.md.",
  "ecosystem": "Ecosystem",
  "ecosystem_desc": "Get official tools and libraries for your project: Pinia, Vue Router, Vue Test Utils, and Vue Dev Tools. If you need more resources, we suggest paying Awesome Vue a visit. ",
  "community": "Community",
  "community_desc": "Got stuck? Ask your question on Vue Land, our official Discord server, or StackOverflow. You should also subscribe to our mailing list and follow the official @vuejs twitter account for latest news in the Vue world. ",
  "support Vue": "Support Vue",
  "support Vue_desc": "As an independent project, Vue relies on community backing for its sustainability. You can help us by becoming a sponsor. "
    "readme": "More instructions are available in README.md.",
  "success": "You’ve successfully created a project with Vite + Vue 3",
  "hello": "Hello"
}

utilis/i18n/fr.json

{
  "documentation": "Documentación",
  "documentation_desc": "La documentation officielle de Vue vous fournit toutes les informations dont vous avez besoin pour commencer.",
  "tooling": "Outillage",
  "tooling_desc": "Ce projet est servi et groupé avec Vite. La configuration IDE recommandée est VSCode + Volar. Si vous avez besoin de tester vos composants et vos pages Web, consultez Cypress et Cypress Component Testing. Plus d'instructions sont disponibles dans README.md.",
  "ecosystem": "Écosystème",
  "ecosystem_desc": "Obtenez des outils et des bibliothèques officiels pour votre projet : Pinia, Vue Router, Vue Test Utils et Vue Dev Tools. Si vous avez besoin de plus de ressources, nous vous suggérons de rendre visite à Awesome Vue.",
  "community": "Communauté",
  "community_desc": "Est resté coincé? Posez votre question sur Vue Land, notre serveur Discord officiel, ou StackOverflow. Vous devez également vous inscrire à notre liste de diffusion et suivre le compte Twitter officiel @vuejs pour les dernières nouvelles du monde Vue.",
  "support Vue": "Soutenir Vue",
  "support Vue_desc": "En tant que projet indépendant, Vue s'appuie sur le soutien de la communauté pour sa durabilité. Vous pouvez nous aider en devenant parrain.",
  "readme": "Plus d'instructions sont disponibles dans README.md.",
  "success": "Vous avez réussi à créer un projet avec Vite + Vue 3",
  "hello": "Bonjour"
}

utilis/i18n/es.json

{
  "documentation": "Documentación",
  "documentation_desc": "La documentación oficial de Vue le brinda toda la información que necesita para comenzar.",
  "tooling": "Estampación",
  "tooling_desc": "Este proyecto se sirve y se incluye con Vite. La configuración IDE recomendada es VSCode + Volar. Si necesita probar sus componentes y páginas web, consulte Cypress y Cypress Component Testing. Más instrucciones están disponibles en README.md.",
  "ecosystem": "Ecosistema",
  "ecosystem_desc": "Obtenga herramientas y bibliotecas oficiales para su proyecto: Pinia, Vue Router, Vue Test Utils y Vue Dev Tools. Si necesita más recursos, le sugerimos que visite Awesome Vue. ",
  "community": "Comunidad",
  "community_desc": "¿Quedó atascado? Haga su pregunta en Vue Land, nuestro servidor oficial de Discord o StackOverflow. También debe suscribirse a nuestra lista de correo y seguir la cuenta oficial de Twitter @vuejs para conocer las últimas noticias en el mundo de Vue. ",
  "support Vue": "Soporte Vue",
  "support Vue_desc": "Como proyecto independiente, Vue depende del respaldo de la comunidad para su sostenibilidad. Puedes ayudarnos convirtiéndote en patrocinador. ",
  "readme": "Hay más instrucciones disponibles en README.md.",
  "success": "Ha creado con éxito un proyecto con Vite + Vue 3",
  "hello": "Hola"
}

If you re-run your application, it should be working perfectly like the screenshot below:

You can find the full working code in this GitHub Repository.

What is Open Source Software? A Beginner’s Guide

Gun — Thu, 29 Jun 2023 12:27:56 +0000

Introduction

If you have been in the tech industry for a while you may have heard about open source or open source software. When we talk about open source, you should think of open collaboration, open exchange, participation transparency and community-oriented development.

In this article, you will learn more about open source software including the difference between open source and other forms of software, key features of OSS, pros and cons of open source, how to start contributing to open source and some examples of OSS.

What is Open Source?

Open source designed any program whose source code can be modified and shared by anyone because it’s openly accessible.

What is Source Code?

A source code is a set of instructions written in the form of functions, descriptions, methods, calls or any other operational statement by a programmer using a computer programming language. A source code can be open that is available to anyone to edit and redistribute or closed. Source code is the part that most software or computer users cannot see.

Example of a Source code taken from Medusa's GitHub Repository

What Does Open Source Software(OSS) Mean?

The term Open source software is a non-proprietary software in which code is publicly available to anyone to inspect, comment on, modify, improve and redistribute it. Open source software is created and maintained by a group of developers so if you are new to computer programming, you can begin your journey as an open source contributor.

I have known open source since 2017 and started with my first contribution in 2020. I made my first contributions to the Apache Software Foundation Gihhub and Mozilla mobile Github.

What is the Difference between Open source Software and other Types of Software?

Do not get confused with open source, free, closed software and freeware. This section highlights the differences between these types of Software.

Open Source vs Free Software

Open source software is software available for anyone to edit, improve and redistribute. The source code is accessible to anyone. Open source promotes collaboration and sharing of source code. It’s an effective way for organizations, developers and individuals to collaborate. Freedom to use the software is not absolute or imposed but it’s allowed. Every open source software is not free. However, some open source licenses are restrictive. WordPress is an example of open source software

Free Software describes software in which source code is free to use, edit and redistribute without any restrictions. With free software, Freedom is a value that is more important than any other thing. All free software is open source software. Ares is an example

Open source and free software have distinguished features. Some open source software is restrictive and all free software are open source software but not all open source software is free software.

Open Source Software vs Freeware

Freeware is any software that is free to use and available to the general public. If you are a, it can be frustrating to use freeware because its source code is not open or rather, it’s closed so you can edit the software to fit your needs. You can only use the features it offers even if it it is limited. Google Chrome is an example of freeware

While with open source software, you have the possibility to edit, improve, and add different features to fit your needs. An example is Chromium.

Freeware source code is closed, only the developer or organization who created the software can view its source code while open source one can edit and redistribute. Freeware is copyrighted while Open source is not.

Open Source vs Proprietary Software

You do not need an authenticated license to use open source software. They function with GNU Public License. They can be installed freely on any computer system. Open source software is developed and maintained through open collaboration.

Proprietary Software is software with protected source code(closed). They cannot be installed on a computer without a valid license. So users need a valid and authenticated license to use it. They are also copyrighted like freeware but the difference is that you do not need to pay to use freeware. An example is Windows

Key features of Open Source Software

In this section, I will elaborate on the various key features and values that cover Open source Software.

Transparency: Open source allows you to track and understand any changes made to software without relying on the software manufacturer.
Collaboration: The main goal of the open source initiative is to allow anyone to freely participate and improve the software. By working together, we can easily identify and solve problems
Meritocracy: Including diverse perspectives from different brains can help identify the best ideas by decision-makers and could equally determine the success of a project.
Community: When many people gather to help and share ideas, it creates a community where each other can get support.
Review: Since source code is freely available to the public, different experimented community members can check, propose ideas and improve the software.
Reliability: Many collaborators can update and test the code to check if there is any bug and fix it. Open sources do not depend on one, two or three people to maintain but rather have a large community that supports them.
Flexibility: Flexibility refers to the fact that you can use open source code to address problems that are unique to your business. Plus you can rely on community help to improve an existing solution or implement a new one.
Lower cost: Most of the time, open source is free to use and download. Sometimes you may need to pay for only reinforcing security and interoperability.

What are the Benefits of Open Source?

Choosing to use or contribute to open source software offers many benefits. Some of them include:

Open source is free
You have more control over the software. Compare to Closed software you can edit open source software to fit your needs.
It's good for anyone beginning computer programming. As a beginner, you can become a better programmer by sharing your work and contributing to other works
Open source is good because it can help to enhance software security as anyone can spot and fix a security issue quickly that the original programmer may have missed
Open source projects tend to be more stable than other types of software since there is a great community behind ready-to-deploy means to improve it.
It promotes collaboration through the creation of communities.
Open source is flexible
They have Good Documentation

What are the Disadvantages of Open Source Software?

Not everyone embraces the open source philosophy. Some organizations still debate the fact that open source software is more vulnerable since their source code is open to anyone.

I have been in the software community for 3 to 4 years now and I have noticed that they tend to be more secure since issues linked to security or not can easily be identified and fixed by community members. However, I equally notice some drawbacks of open source.

Open source software can be difficult to set up, especially for beginners. Some of them may lack user-friendly interfaces imposing you to use a Terminal
Liability problems. Open source rarely contains warrant or liability protections
Compatibility issues.
Initially, there is no cost but it can be costly in the long term especially if you need immediate support. There is also training cost in case you incorporate the software into your team.
Not all open source possesses a user manual although you can seek help from the community it won't always be available immediately like commercial software where support is available 24h/7

How can you Start Contributing to Open Source?

It’s quite simple to contribute to open source software. You could do that by identifying and fixing bugs, adding features, improving documentation and writing content in the form of blog posts, technical tutorials or creating Videos. You also create your own open source project to promote open source.

To contribute to existing open source software, you should head to GitHub:

Find a project and Fork
Clone the Project to your Local machine
Create a new branch
Make changes
Commit your changes
Push your changes to your remote repository
Finally, Create a pull request

If you don’t have any project ideas, then open source projects to contribute to include

Open Source License

An Open source License governs how other individuals besides the initial developer can use, modify and redistribute the software. It allows the software to be transparent and changed by members of a community or third party. According to the Open Source Initiative include

Example of Open Source Software

You might have used an open source software without realising. There are many of them out there. Some popular and most-used open source software is

WordPress, an open source CMS for Content Management
Flutter for web, desktop and mobile development
CSS Frameworks Like Bootstrap for website layout
VLC Media Player for video and sound player
Libre Office for word processing
Open source Linux Operating System
Python is open source too.
Open source reporting tools include Metabase, BIRT
Open source PDF viewer include Qoppa PDF Studio, pdfFiller, and Soda PDF
Some Java open source projects are Arduino, Mindustry, and Signal Android
We equally have open source development tools like Eclipse IDE, and Apache Cordova

FAQ

Is Open Source Software Free?

Most open source software is free but there are some exceptions. Some open source licenses are restrictive and do not allow the creation of a modified version. An example is Open Source Watcom

Where can I find OSS?

You can find and download open source projects on SourceForge, OSDN, FossHub, GitHub, and F-Droid

Why Should you Contribute to OSS?

The most important advantage of contributing to open source is that you can find and collaborate with other developers hence improving your developer network.

Why is Open Source Important?

Open source improves innovations through collaboration with other organizations and developer

What are Some Open Source Competitions?

Open Source Competitions are contests where you can learn to participate in open source projects, demonstrate your coding skills, and get feedback. Examples of Open source competitions include Open Source Contest, Google Summer of Code (GSoC), Outreachy, Open Summer of Code, Free Software Foundation (FSF) Internship Program, GirlScript Summer of Code (GSSoC)

What is Closed Source Software?

Closed Software is software whose source code is only available to the author. So only the author can modify and copy it.

What is the Open Source Initiative?

The Open Source Initiative is a non-profit organisation with the main aim to educate about, form, and inform the benefit of open source

Conclusion

Open source is available for anyone to edit, use and redistribute. Some key features of open source include transparency, reliability, available community and flexibility. However, OSS can be costly in a long run. So if you are planning to incorporate OSS into your business you need to include additional or urgent costs in your project plan including the cost of training staff members to use the software. Some popular Open source projects include Apache, WordPress, and Mozilla Firefox.

If you like this kind of content, feel free to share or subscribe to our newsletter below to get fresh content like this periodically. But if you have any questions, you can reach me via my twitter account. I will be glad to hear from you.

Let's Flutter Together Today

Gun — Thu, 06 Apr 2023 15:00:06 +0000

Photo by Randall Ruiz on Unplash

Nowadays mobile application is growing exponentially. Many people use smartphones these days either for automation, relaxation, GPS for directions, keep track of appointments and contacts. In fact, many employees and businesses have trouble just imagining a day without a smartphone or mobile device. As people evolve over time so are the different tools used to build most software found in smartphones. Please note that Flutter is also used to build web and desktop apps. Here I will only focus on mobile applications. Then What is Flutter- Why should you learn Flutter in 2023?

In this article, I will briefly introduce Flutter to you and list some companies or apps which use or build applications using it.

Flutter is an Open source toolkit used to build expressively beautiful, natively compiled applications in a single code base. One of its benefits and why I will encourage you to use it in your project is the fact that you can build amazing UI and fancy animations. You also have the possibility to build an app that will run on different operating systems. The factor is commonly known as cross-platform. But apart from this why should you learn Flutter in 2023?

Fast Development with Flutter

Flutter provides a feature known as hot reload which helps you to quickly build and test your UI as well as fix some bugs related to them without having to re-run the whole app. Flutter framework automatically rebuilds the widget tree in order for you to quickly view the effects of any changes.

Native Performance

Flutter’s widgets provide most of the native components such as scrolling, navigation, icons and fonts to provide full native performance on both iOS and Android.

Flutter, a Wonderful Documentation

Even if you are new to mobile development or not flutter offers highly detailed and comprehensive documentation to help developers or none developers acquire the knowledge needed to perform a particular task.

Ready-to-use tutorials

Truly if you are not still satisfied with the documentation you can go ahead and download tutorials on Udacity, Udemy or any other platform which offers complete mastery tools. These tutorials may help you polish up your skills since they usually contain practical projects.

Learn from Developers

Learning does not imply learning on your own. There are many developers with outstanding experience as well as forums such as Stack Overflow or GitHub forums to help. Just be humble to yourself and accept to receive and share knowledge with others.

Who is using Flutter?

I forget to mention it but Google is actually the one who is behind the Flutter framework and many companies around you may know actually use it. Some of those companies are

Google,
Groupon,
EMAAR,
UNbank,
Ebay,
Alibaba group,
CapitalOne
Tencent,
Square,
SONOS... and many other organizations

Some applications around us which are built using Flutter...

For example, we have,

Google Ads at the top of this list,
Insight Timer,
Abbey Road Studios,
Baidu,
ByteDance,
Hamilton,

Ahhh! I have just been talking about the positive aspects of Flutter. What about the drawbacks, Well Flutter has a handful number of disadvantages just as it has great abilities.

So what are its drawbacks? Let's flutter together today to expose them.

I hope you were able to learn something from this article and wish this article will help you understand more and choose the right technology that will help you to build awesome apps either with or without Flutter. Take your time to choose and then get started right away.

Want more? then you could check this detailed article about Flutter

WordPress, Yet Another CMS

Gun — Thu, 06 Apr 2023 14:17:06 +0000

Photo by Markus Winkler on Unsplash

I recently talked about WordPress.com and WordPress.org in my previous articles and actually I have been getting requests from people asking what WordPress actually is. Today you will finally feel relief cause I will give you a brief introduction to WordPress. So guys sit and get a cup of tea to savour this.
WordPress… just another CMS

WordPress is actually a free and open source Content Management System written in PHP and associated with MySQL or MariaDB databases. Initially, it was created as a blog publishing-System. But it has evolved to include different web content types (such as online stores, membership websites, forums, and media galleries…).
CMS… What is it?

Content System Management also known as CMS is simply an application that is used to manage web content. In general, it allows a contributor or contributors to create, edit, publish or destroy content(web pages, articles…). A contributor can be any person who has access to a WordPress Dashboard

WordPress is equally one of the most popular content system management used today. It has also been used for other application domains such as pervasive display systems.

The software was released under the GPLv2 license. Founded by an American developer Matt Mullenweg and Mike Little an English developer. WordPress is also called a factory that makes webpages. It comes along with many tools to ease management. Some of these tools include themes and plugins.

Below you will find a screenshot of a section of WordPress Dashboard

As you can see in the shot above, the WordPress Dashboard has many tools you can use to manage your web content. To have a better experience just install WordPress and take a look around. If you would like to set up WordPress on your own don’t worry here is a tutorial on how to install it locally.

To conclude, WordPress is an application used for building web platforms. Be it a blog, a website, or a portfolio, WordPress facilitates and eases your efforts to build such platforms. For example MangAnime tradnow and Learndevtools are two blogs which talks about anime and development build essentially with WordPress

Last but not least there exist different versions of WordPress. Some of us can use WordPress.com(Practically no coding). Then developers have the chance to get beautiful documentation in order to customize and bring in some innovations with WordPress.org.

I hope I was able to answer most of your questions guys. Feel free to ask more questions. I will be glad to understand and help you.

Medusa Vs Woocommerce: Comparing Two Open source Online Commerce Platforms

Gun — Mon, 20 Mar 2023 10:57:53 +0000

Introduction

Woocommerce is an open source, customizable ecommerce platform built on WordPress. Woocommerce offers features like flexible and secure payment and shipping integration. It is written in PHP which is a universal language that can be used to build complex applications.

On the other hand, Medusa is an open source composable commerce engine built with Node.Js. It offers out-of-the-box features like multi-currency support, plugin integration support, and tax configurations among many others. Besides these, Medusa is known for its Return Merchandise Authorization (RMA) flows and how it is fully customizable.

Through this article, you will learn why open source ecommerce tools are essential, how to choose a tool for your ecommerce, and the difference between Woocommerce and Medusa open source online commerce platforms per developer’s experience and the general ecommerce features they offer.

What is an Open Source Ecommerce Platform?

Open source refers to software that has its source code publicly accessible for anyone to see, modify, modify, contribute to, and distribute as they want. An open source ecommerce platform is software that gives you full access to the source code, allowing you to customize the ecommerce platform to meet your needs and equally giving you total control over your store.

What is Woocommerce?

Woocommerce is a WordPress plugin used to build an online store. Woocommerce's first version was launched in 2011 and became extremely popular. In 2014, the plugin hit 4 million downloads.

At the time of writing this article, Woocommerce has over 5 million active installations and 8.3k stars on GitHub. Woocommerce is a beginner-friendly tool, so you don’t need to be an expert developer to use it. Additionally, there are thousands of free and paid themes on Woocommerce.

Woocommerce's main aim is to enable you to create an online store with just a few clicks and start selling. Woocommerce runs under WordPress; after creating your Woocommerce account, you will create a WordPress account and give some permission to Woocommerce before building a store. You will need to set up a WordPress installation before setting up a Woocommerce store.

What is Medusa?

Medusa is a JavaScript-based open source tool for building online stores. Medusa was launched in 2021, aiming to provide a great experience to developers building an ecommerce platform, using NodeJs as an engine.

Although Medusa is newer than Woocommerce, it becomes increasingly popular each day as it’s being adopted by companies and individuals across the world. What attracts businesses and developers mostly is the customization ability Medusa offers.

Medusa also offers other out-of-the-box features like bulk export and import, creation and management of multiple sales channels, configuration and management of many regions on one platform, addition, customization, and sorting of products into collections, and many more.

Medusa is made up of 3 components:

The Medusa Server: It’s a headless backend built on Node.js and it's the main component that contains all the logic and data of the store.
The Admin Dashboard: The store operator uses this component to manage the store, i.e. add, remove and update products, and customize and manage the store settings.
The Storefront: Here, customers can view products and place orders. By default, Medusa offers 2 storefronts. One is built with NextJs and the other Gatsby, but you could build your own storefront using the Storefront REST APIs.

Medusa Vs Woocommerce

This section highlights the difference between Medusa and Woocommerce in terms of the general features both offer and the developer’s experience.

General Features Comparison

Payment Gateways

Woocomerce and Medusa allow both developers and businesses to integrate third-party payment solutions. Woocommerce has a variety of ready-made extensions to integrate payment. Most of these payment gateways support Stripe, Paypal, Verifone, Apple Pay, and Amazon Pay.

Developers can integrate payment methods in their Medusa store using payment providers such as Klarna, Paypal, and Stripe with existing plugins. However, as a developer, you could also create a plugin to integrate other payment methods.

Live-Chat Integrations

A live chat will help engage more visitors and increase customer satisfaction across many channels.

Woocommerce offers extensions like LiveChat that you can install and set up on your store. WordPress has many plugins for live chat Integration compatible with Woocommerce and some of them include LiveChat's WordPress Plugin, OLark WordPress Plugin, Tidio WordPress Plugin, Chatwoot, and WP Social Chat.

Medusa, on the other hand, offers many ways to integrate Live Chat with Tidio, Chatwoot, Zendesk, Hotspot, ChatBot, and many others. In addition, Medusa plugin systems make it easier to create plugins and integrate with these chat services.

Taxes

Woocommerce offers a simple way to manage taxes, but before configuring your tax, you need to enable taxes. You can choose to either include taxes in your product’s prices or charge taxes separately. You can set up taxes to be applied in a specific region.

Taxes are available out-of-the-box in Medusa. Like Woocommerce, you can manage taxes in specific regions as well as add multiple tax rates.

Medusa provides a Tax API to developers that allow them to further integrate third-party services.

RMA Flows

Woocommerce offers a powerful and reliable RMA tool for selling, managing, processing warranties, and handling return requests within your Woocommerce store. However, you need to download the Woocommerce Product RMA, install, activate and configure it. Unfortunately, this product is not free.

RMA Flows are available out-of-the-box in Medusa and customers can send requests to return items from an ecommerce store. The admin or store operator can manage the order status, shipping, and payment.

Shipping

Woocommerce allows you to set up shipping zones and add methods to those zones and rates to your shipping methods. Users can create as many zones as possible and add methods and rates.

Medusa allows developers to integrate third-party providers like WebShipping. Medusa has 4 components in its shipping architecture: fulfillment provider*,* shipping options, shipping methods, and shipping profiles which are the highest in the hierarchy of shipping. However, developers can equally create plugins to manage any shipping provider.

Admin Dashboard

Woocommerce does not have an admin dashboard on its own but rather uses the WordPress dashboard since it’s functionally built to use WordPress. When you install the plugin, the Woocommerce menu appears on the sidebar of the WordPress dashboard.

The dashboard is simple and allows you to manage products, orders, Extensions, Reports, and other features. You need to know how the WP admin dashboard works to use Woocommerce.

Medusa has a simple and fluent admin dashboard. The dashboard allows you to manage products, price listings, customers, regions, currencies, settings, and many other elements of your store.

Localization

Woocommerce does not offer localization options on its own. To localize your store, you need to install a plugin like PoEdit, Loco Translate, or MultilingualPress.

Currently, the localization feature is not also available out-of-the-box in Medusa. But it can be implemented using CMS plugins like Contentful.

Multi-currency Support

Unfortunately, multi-currency is not available out–of–the–box in Woocommerce. To set up multiple currencies in your online store, you need to purchase the Currency Converter Widget extension and set it up. There are other extensions like Woocommerce Multi-Currency or Multi-Currency Switcher which are also not free.

Medusa supports the multi-currency feature. A business can set up a region and choose specific regional settings such as currency. Additionally, the business can manage each region from one store, hence eliminating the need to create many stores or switch between them

Gift Cards

You can create and sell prepaid multipurpose gift cards to customers, which they can redeem at your store. Gift cards are not available out-of-the-box in Woocommerce. Some Woocommerce gift card extensions require at least version 3.9. of Woocommerce. They are not free of charge.

Gift cards are available in Medusa out-of-the-box. Merchants can specify multiple denominations and images. Customers can then purchase the gift cards as if they were buying a product. However, gift cards are not packaged and shipped like products. Customers can receive it in the form of a link or by email.

Reporting and Analytics

Woocommerce offers an analytical board where you can view your number of sales, net sales, number of orders, products sold as well as variation sold. You can compare your sales per date and even download your reports for further utilization.

Right now, Medusa does not provide any analytic module but developers can use third-party services to add analytical features. Fortunately, with the flexibility Medusa offers, developers can easily implement and integrate third-party services in their store.

Speed and Performance

The process of creating a store with Woocommerce is quite fast. With a few clicks, you will have your store set up and ready to sell. If you need to measure the speed and performance in terms of the tools used to build the frontend and backend, this will be different since Woocommerce is not a headless commerce. You can optimize the speed and performance of your store in various ways.

For example, if you decide to use a lighter framework or just pure CSS rather than using Bootstrap, the number of stylesheet files will considerably reduce, and the pages will load rapidly increasing user experience as well as some SEO factors hence improving the speed ad performance of your store

Medusa's headless architecture allows you to separate the backend from the frontend. This makes it faster and lighter compared to tightly coupled architecture. So you can decide to use a lighter framework or fewer resources for both your backend and frontend and this can greatly impact the speed and performance of your store.

In addition, you can set up your store following this quick guide and the process is fast since in just three steps, you will now have a complete commerce engine running. However, if you need advanced functionalities then you can check the complete Documentation

Developer’s Features Comparison

This section presents a brief comparison between Medusa and Woocommerce in terms of developer features

Documentation

Both Woocommerce and Medusa provide extensive documentation for both developers and business owners. Woocommerce codex provides a library of documentation and tutorials to set up, customize and expand your online store whereas Medusa has a detailed user guide to help you get started.

Community

Developers can contribute or report bugs on Woocommerce’s GitHub repository.

Medusa is an open source platform whose aim is to build a strong and collaborative relationship with the community. Both developers or tier persons can join the Discord server to stay up to date with current trends and request and receive help from the community members as well as the core Medusa team.

Developers can equally showcase their work, report bugs, propose fixes or contribute to issues to the Medusa platform on its GitHub repository. There are other channels like Twitter and LinkedIn that developers can join to bring their contribution or get help.

Installation and Time to Get Started

WooCommerce’s installation guide shows you a step-by-step process on how to install and set up your online store easily. To get started with Woocommerce, developers need to know PHP, HTML, CSS3, and WordPress. Non-developers can install WooCommerce via WordPress.com.

Medusa provides a quick guide that allows developers to create and manage their store in just 3 steps: Installing Medusa CLI with yarn or npm, creating a new Medusa project using the CLI, and starting the Medusa server.

In less than 4 steps, you will have a store set up with the features mentioned earlier. You’ll then need to set up the admin and storefront with Gatsby or NextJs to effectively manage your store. Medusa ecommerce store is written in Typescript and JavaScript essentially and uses SQLite as a database if no database engine is set up.

For production purposes, it’s recommended to install and configure a PostgreSQL database and Redis to handle events. The step-by-step process to install and manage these tools for various OS is included in the Medusa documentation.

Deployment and Upgrade

Since Woocommerce is built on top of WordPress, it’s recommended to deploy the online store on a WordPress deployment plan hence restricting deployment on any cloud hosting.

Woocommerce deals mostly with updates rather than upgrades. Before thinking of updating your Woocommerce store, it’s recommended to manually back up or automatically back up your store.

Unlike Woocommerce, Medusa can be deployed on any cloud hosting. In its documentation, you can find a straightforward guide on how to deploy on various platforms like Heruko, Digital Ocean, or Qovery.

Upgrading Medusa is quite simple; however, some versions may require you to run migration scripts or take additional actions. Fortunately, Medusa provides an upgrade guide with detailed steps to follow.

Customization

Woocommerce is not a headless architecture. Nevertheless, you can build a WooCommerce headless store on your own. This is not recommended, though, as Woocommerce is not designed for this purpose and it does not have the tools or features to build one.

The fact that Medusa has a headless architecture allows anyone to easily and freely customize their storefront. You can choose any framework or programming language to use on your frontend. This also applies to the admin dashboard. Creating custom features is like adding a JavaScript file that loads automatically into Medusa as soon as you run the server.

The backend uses an API so developers can extend these APIs to add third-party services and custom features.

Developer’s Level

You don’t need to be a developer to be able to set up a store with WordPress and Woocommerce. You can set up your online store with just a few clicks. However, if you need advanced features and more customization, then you may need to hire an experienced developer to build those features or make them by yourself.

Medusa has a simple and understandable architecture. As a developer, you just need knowledge of JavaScript/TypeScript and NodeJs. Both the Medusa storefront and admin dashboard are built with JavaScript Frameworks.

Due to the decoupled nature of Medusa, you can create the admin dashboard and storefront with any language or framework. All you need is to link the backend using REST API.

Summary of Medusa vs Woocommerce

Property	Medusa	Woocommerce
Language	TypeScript	PHP
API	REST API	REST API but you need to enable it in the Woocommerce settings
Stars on GitHub	https://github.com/medusajs/medusa	8.3k
License	https://github.com/medusajs/medusa/blob/master/LICENSE
Activity	Since 2021	Since 2011
Latest Release	1.7.5(5 days ago)	7.3.0(2 weeks ago)
Platform	-	WordPress
Mobile App	No	Yes
RMA Flows	Yes	Yes
Taxes	Yes	Yes
Localization	No	No
Multi-Region Support	Yes	Yes
Gift Cards	Yes	Yes
Headless Architecture	Yes	No
Customization	Highly Customizable	No

Conclusion

In this article, you learned the difference between Woocommerce and Medusa based on the features each ecommerce store offers and the developer’s experience. Choosing the best ecommerce platform is an important decision to reflect on because taking the wrong decision may greatly affect your business in the long run.

Woocommerce is easy to set up and can handle both smaller and bigger businesses. It is a good choice for non-developers and developers who know PHP and WordPress.

Medusa is a perfect choice for anyone aiming to build headless commerce. Medusa can equally manage both larger and smaller businesses. It’s a good choice for developers with great JS/TS skills, looking forward to building a NodeJs ecommerce Platform. If you want to design your storefront and admin dashboard then Medusa is also a good choice.

DEV Community: Gun

Building an SEO competitor-analysis Actor with Crawlee and Apify

Prerequisites

What the Actor does

Why this problem is harder than it looks

Project setup

Defining the Actor input

Crawling strategy

What I actually need from each page

Adding a comparison snapshot

Testing the crawler on another topic

Enhancing the extraction

Deploying the Actor on Apify

Scheduling runs

Enhancing capabilities

Conclusion

Localizing SaaS Applications: What Developers and Writers Get Wrong

Localizing SaaS Applications: What Developers and Writers Get Wrong

First, Understand What You Are Actually Doing

What Developers Get Wrong

Hardcoding User-Facing Strings

String Concatenation

Ignoring Layout Flexibility

Treating Locale as a Display-Layer Problem

What Writers and Content Teams Get Wrong

Writing Source Copy That Cannot Be Localized

Sending Strings Without Context

Treating Localization as a One-Time Release Task

Where SEO Enters the Localization Workflow

The Structural Problem Underneath All of It

It Is a Systems Problem, Not a Language Problem

Sources and Further Reading

How to Analyze a CSV File with Python and Pandas

Create the Sales CSV File

Load the CSV File With Pandas

Inspect the Data Before You Clean It

Clean the CSV Data

Analyze Sales With groupby()

Visualize the Results

Working With Larger CSV Files

Export Your Cleaned Data and Summaries

Common Mistakes When Analyzing CSV Files

Best Practices Checklist

What Learned Today

How to Integrate YouTube Video Player in a Flutter Application

Objectives

Common Use Cases Where You Should Add YouTube Integration in Your Mobile App

Integrating Video Tutorials

Integrating in Movies Application

Informational oriented application

Monetization

Live Stream Events

Product Demonstrations

Travel

Fitness and Music

Integrating YouTube in a Flutter Application

Prerequisites

Creating a Flutter Application

Adding YouTube Package

Incorporating Features and Customizing YouTube Player

Show Video Progression Indicator

Progress Indicator Color

Setting FullScreen Mode

Adding Players Control

What’s Next

Conclusion

Resources

Opensea vs Blur: Which Platform Suits Your Needs?

OpenSea: The Gateway to NFTs

Key Features:

Pros:

Cons:

Blur: The Professional’s NFT Marketplace

Key Features:

Pros:

Cons:

Comparing OpenSea and Blur

For Beginners and Enthusiasts:

For Artists:

For Professional Traders and Investors:

Analyze Sales With `groupby()`