CodeIsGo.com

PostHog and Matomo serve distinct analytics purposes: PostHog excels in product analytics for SaaS applications, while Matomo is a robust web analytics platform. Both support self-hosting via Docker, but differ in resource usage and feature sets. By Alex Thornton.

PostHog and Matomo are both open-source analytics platforms, but they cater to different use cases. PostHog is designed for product analytics, offering features like session replays, feature flags, A/B testing, and funnel analysis—ideal for SaaS products needing deep user behavior insights. Matomo, on the other hand, is a mature web analytics tool that tracks pageviews, referrers, bounce rates, and goal conversions, making it a strong alternative to Google Analytics.

Quick comparison notes

• PostHog: Product analytics, feature flags, A/B testing, session replays.
• Matomo: Web analytics, GA replacement, GDPR compliance, plugin ecosystem.
• PostHog requires 16GB+ RAM; Matomo runs on 2GB.
• Matomo supports heatmaps/e-commerce via plugins; PostHog includes them natively.
• PostHog’s hobby deployment limits event volume.
• Matomo is better for low-resource environments.
• Use both tools for web and product analytics.

Both platforms support Docker-based deployment, with Matomo running on two lightweight containers and PostHog leveraging ClickHouse for scalable event data storage. While Matomo is known for its stability since 2007, PostHog provides more modern product-centric tools. The choice depends on whether you’re analyzing website traffic or in-app user interactions. For developers prioritizing data privacy and self-hosting flexibility, both are strong contenders, but their strengths lie in different domains. Nice read!

Matomo 5.8 introduces a dedicated AI-assistant tracking module that enables self-hosted analytics platforms to isolate genuine human demand from AI-generated noise. This update transforms self-hosted measurement from a privacy checkbox into a critical attribution control layer for SaaS founders and growth engineers navigating an era where chatbots and voice assistants generate significant referral traffic. By ImaLamer.

The release of Matomo 5.8 marks a significant shift in how we approach analytics in the age of AI assistants. With chatbots and voice assistants increasingly fetching pages on behalf of users, traditional analytics platforms struggle to distinguish between human-driven demand and AI-generated noise. Matomo’s new AI-assistant tracking module addresses this challenge by providing a dedicated solution for isolating genuine user interactions from automated traffic.

Some main points for this release:

• AI assistants inflate referral traffic and skew funnels by performing server‑side fetches that appear as legitimate referrals.
• Matomo 5.8’s on‑premises AI‑assistant module classifies bot traffic, isolates it in reports, and keeps data private.
• Self‑hosting cuts event‑based overage costs, offers pipeline flexibility, and improves reliability versus adding another SaaS product.
• Deployment is straightforward with Docker Compose; enabling the module requires a single config flag.
• Real‑world case: 18 % drop in CAC and $220/month savings after isolating assistant traffic.
• Trade‑offs: patching, feature parity lag, and data‑residency compliance need active management.
• The shift signals that privacy‑first tools are evolving into strategic growth assets for AI‑heavy traffic.

This update transforms self-hosted analytics from a mere privacy consideration into a practical attribution control layer. For indie SaaS founders and growth engineers, owning the measurement stack becomes the simplest way to maintain accurate attribution without introducing additional hosted analytics products. The module specifically targets the problem of mixed referral signals, where AI assistants and crawlers create noise that obscures true user behavior.

By implementing this feature, organizations can now implement more sophisticated attribution models that account for the unique characteristics of AI-assisted interactions. This approach not only improves data accuracy but also maintains full control over sensitive user data, addressing both privacy concerns and measurement challenges simultaneously. Good read!

Microsoft’s Azure Linux 4.0 is now available for bare-metal and VM installations, marking a significant shift from cloud-only deployment. This move positions Azure Linux as a viable competitor to mainstream enterprise Linux distributions and potentially challenges Windows Server’s dominance in hybrid environments. The release underscores Microsoft’s commitment to open-source and multi-platform strategies, offering enterprises greater flexibility in their infrastructure choices. By Steven Vaughan-Nichols.

This distribution, designed primarily for Azure, now offers enterprises the option to deploy Linux outside the cloud, challenging traditional Linux distributions and potentially disrupting Windows Server’s entrenched position in hybrid environments. The availability of Azure Linux 4.0 reflects Microsoft’s broader strategy to embrace open-source technologies and provide flexible infrastructure solutions.

Some main facts about Azure Linux 4.0:

• Azure Linux 4.0 is downloadable for on-premises and VMs, expanding beyond Azure-exclusive use.
• Built on Fedora’s RPM ecosystem, optimized for Azure/Hyper-V with a Linux 6.18 kernel.
• Dual support model: Azure Marketplace images include SLAs; ISO standalone use is community-supported.
• Integrates with Azure services (Defender, confidential computing) for hybrid cloud consistency.
• No GUI, designed for CLI-focused, cloud/server workloads.
• GitHub project enables custom image builds but retains Microsoft’s curated control.
• Potential to challenge enterprise Linux distros and replace Windows Server in the long term.
• Still in beta, with limited standalone support and vendor-controlled development.

By enabling self-hosted deployments, Microsoft aims to attract enterprises seeking multi-cloud or hybrid setups, where Linux’s efficiency and cost-effectiveness are critical. This move not only strengthens Azure Linux’s credibility but also signals a potential shift in enterprise IT landscapes, where Linux may increasingly replace Windows Server in certain use cases. The release is a testament to Microsoft’s evolving stance on Linux, positioning it as a serious contender in the enterprise server market.

Azure Arc promises streamlined management for on-premises SQL Server estates, but real-world adoption reveals unexpected complexities. This post explores the ‘Arc Inversion’ — where perceived technical hurdles are actually the easy parts, and the true challenges lie in organizational alignment, process transformation, and cultural shifts required for successful cloud integration. By Neil Bryan.

Managing legacy SQL Server 2012 installations often triggers painful conversations about end-of-support, licensing costs, and security risks. Azure Arc appears to be the silver bullet: unified cloud control plane, simplified licensing, and automated inventory management. Yet after extensive onboarding experiences, a recurring pattern emerges - what I call the ‘Arc Inversion.’

The technical challenges - integrating on-premises resources with Azure, configuring security policies, and establishing connectivity — are actually the straightforward parts. The real difficulties emerge in less visible areas: organizational resistance to new workflows, siloed teams struggling with shared responsibility models, and the cultural shift required when infrastructure management moves from isolated teams to cross-functional collaboration.

Successful Azure Arc adoption demands more than technical implementation. It requires rethinking how teams collaborate across traditional boundaries, establishing new governance frameworks, and preparing for the operational changes that come with unified management. The technology is ready; the challenge is ensuring your organization is equally prepared for the transformation it enables.

This article is a must-read for enterprises deploying Azure Arc, offering actionable insights into operational pitfalls that often go unmentioned in official documentation. It bridges the gap between Arc’s theoretical benefits and real-world implementation, emphasizing that success hinges on meticulous planning rather than technical complexity. Its value lies in preventing costly surprises, making it a critical resource for DBAs and architects managing legacy estates. Great read!

ggsql introduces a SQL-based grammar of graphics, enabling developers and data scientists to create rich visualizations directly within SQL queries. This tool integrates seamlessly with environments like Jupyter notebooks and VS Code, streamlining the data visualization workflow. By Thomas Lin Pedersen, Teun Van den Brand, George Stagg, Hadley Wickham.

ggsql is an innovative tool that brings the grammar of graphics to SQL, allowing users to describe visualizations directly within SQL queries. This approach simplifies the process of creating charts and graphs by leveraging the familiar SQL syntax. The tool is designed for use in environments such as Jupyter notebooks, VS Code, and Positron, making it accessible to a wide range of developers and data scientists.

ggsql supports a variety of visualization types, including scatterplots, line charts, and histograms. The tool uses the built-in penguins dataset for demonstration purposes, showcasing its ease of use. For instance, a simple scatterplot can be created using the following SQL query:

VISUALIZE bill_len AS x, bill_dep AS y
FROM ggsql:penguins

The primary motivation behind ggsql is to bridge the gap between data analysis and visualization. By enabling users to create visualizations within SQL, ggsql reduces the need for switching between different tools and languages. This integration streamlines the workflow, allowing for more efficient data exploration and presentation. Interesting read!

This guide demonstrates how to build a production-ready admin dashboard for Ollama that runs on both Android and Desktop using Kotlin Multiplatform. By leveraging Compose Multiplatform, developers can achieve approximately 95% code sharing between platforms, significantly reducing development effort and maintenance overhead. By Vitali Tsikhanovich.

Building a cross-platform dashboard for Ollama using Kotlin Multiplatform offers significant advantages in code reuse and maintenance efficiency. This tutorial walks through creating a production-ready admin dashboard that runs on both Android and Desktop with approximately 95% shared code. The implementation leverages Compose Multiplatform to create a unified UI layer while maintaining platform-specific optimizations where necessary.

The architecture follows the Model-View-Intent (MVI) pattern, ensuring predictable state management and clear separation of concerns. Key features include model lifecycle management, registry discovery, VRAM monitoring, and streaming downloads—all integrated through Ollama’s REST API. The project setup requires Kotlin, coroutines, and basic Compose knowledge, along with a running Ollama instance. Developers will configure the Multiplatform environment, set up dependency management, and establish the shared module structure.

Implementation steps include defining shared data models, creating platform-specific adapters, and building the UI layer with Compose. The tutorial emphasizes best practices for state management, error handling, and network communication in a multiplatform context. By following this guide, developers can create a robust, cross-platform dashboard that provides comprehensive Ollama management capabilities across mobile and desktop environments, significantly reducing development time and maintenance overhead while maintaining high code quality and performance. Interesting read!

Expo SDK 56 introduces a Kotlin compiler plugin that eliminates runtime reflection from Expo Modules on Android. A new Kotlin compiler plugin in SDK 56 strips reflection from Expo Modules on Android: 70% faster init, no code changes for app developers. By Łukasz Kosmaty.

Expo replaced the expensive runtime reflection used to discover type metadata in Android modules with a Kotlin compiler plugin. Instead of asking the JVM about types and object shapes at startup, the compiler pre-computes that information during build and bakes it directly into the bytecode.

The plugin operates on Kotlin’s intermediate representation (IR) during compilation. It targets two reflection-heavy operations:

1. Type resolution — calls like typeDescriptorOf<T>() are replaced at compile time with pre-built, cached type descriptors. No runtime reflection needed.
2. Record conversion — classes marked with @OptimizedRecord have their property names, types, and accessors compiled into direct bytecode instructions. The runtime skips reflection entirely and falls back gracefully if the annotation is absent.

Measured on a module-heavy test app across a OnePlus 9 Pro and a Samsung Galaxy S9:

• Module initialization: ~70% faster
• Time to first render: ~30% faster
• Record conversion: *~6x faster

The approach leverages Kotlin 2.0’s K2 compiler plugin API, which allows modifying code during compilation rather than generating parallel files. Good read!

Bypass PHP’s visibility rules with Spatie’s invade package - simple closures let you read, write, and call private members for testing or deep integration. By Freek Van der Herten.

The article details a practical technique for breaching PHP’s private visibility barriers using the spatie/invade library. It begins by presenting a concrete example of a class with private properties and methods, then shows how direct access would normally trigger a fatal error. The solution is an invade() function that returns an Invader wrapper.

Historically, the wrapper relied on PHP’s Reflection API: it would instantiate a ReflectionClass, locate the desired property or method, make it accessible via setAccessible(true), and retrieve or assign values. While functional, this approach required per‑access Reflection objects and explicit accessibility toggling. The breakthrough came from recognizing that private visibility is confined to the class definition itself; any code executing within that class can access all private members of any instance, regardless of which object owns them.

By crafting closures that are executed with Closure::call($targetObject), the closure’s $this context and scope are rebound to the target object, placing the closure’s code inside the class’s scope and thereby granting it privileged access. The current Invader class embodies this concept in just three magic methods: __get creates a closure to read a property, __set assigns a value, and __call invokes a private method with any arguments. Each closure is immediately executed with ->call($this->obj), seamlessly bypassing visibility checks without Reflection.

The author notes that while powerful, invade should be reserved for scenarios where direct access is indispensable, such as test suites or deep‑integration libraries. Nice one!

The article compares Plausible Community Edition and Matomo—two open‑source, self‑hosted web‑analytics platforms. By Alex Thornton.

Plausible and Matomo are open-source, privacy-first web analytics tools. They serve as privacy-focused alternatives to Google Analytics, designed to help website owners track visitor traffic and behavior without compromising user data.

Some key findings:

• Plausible’s tracking script is <1 KB and cookie‑free, eliminating consent banners.
• Matomo provides full Google Analytics feature parity, including e‑commerce, heatmaps, and session recordings.
• Plausible uses ClickHouse + PostgreSQL (≈500 MB–1 GB RAM); Matomo uses PHP + MariaDB (≈300–500 MB RAM).
• Installation: Plausible requires three Docker containers; Matomo needs two containers plus a cron job.
• Performance: Plausible scales better for high‑traffic sites; Matomo can slow with large datasets due to archiving spikes.
• Community: Matomo has a larger, older ecosystem; Plausible’s community is younger but active.
• Use‑case guidance: Choose Plausible for simplicity and privacy; Matomo for advanced analytics needs.
• Both can coexist on a single server if sufficient RAM (~1.5–2 GB) is allocated.

The article compares Plausible Community Edition and Matomo—two open‑source, self‑hosted web‑analytics platforms. It targets developers, DevOps engineers, and UX designers who want privacy‑respecting, lightweight analytics. Plausible excels with a tiny tracking snippet, a clean single‑page dashboard, and zero‑cookie operation, making it the go‑to choice for simplicity and GDPR compliance.

Matomo, by contrast, offers comprehensive feature parity with Google Analytics—including e‑commerce, heatmaps, session recordings, and GA data import—at the cost of higher complexity and resource usage. The piece outlines installation steps, performance implications, community support, and use‑case guidance, helping technical readers decide which tool aligns with their project’s functional and operational constraints. Nice one!

Combining the creativity of artificial intelligence with the rigor of formal specification methods and the power of formal program verification, supported by modern proof tools. By Bertrand Meyer.

Bertrand Meyer contends that AI’s rise in software engineering, while promising, faces critical limitations due to “hallucinations” and probabilistic outputs. Unlike domains like medical AI, software demands near-perfect correctness, especially in mission-critical systems. Meyer advocates combining AI’s creativity with formal specification and verification to address these risks.

Some points discussed:

• AI’s probabilistic nature risks “hallucinations,” making it unreliable for critical software.
• Formal verification (mathematical proofs) is essential for ensuring correctness in complex systems.
• A hybrid approach combining AI (for creativity) and formal methods (for rigor) is necessary.
• Iterative processes are required, similar to debugging, to refine specs/code and verify them.
• AI can assist in generating specifications and annotations for verification.
• Tools like AutoProof and Dafny exemplify this integration but face usability challenges.
• Critical software (A/B categories) demands this hybrid model; casual applications (C) may rely on AI alone.

AI can generate code or specifications, but formal tools must validate them via mathematical proofs. This hybrid approach synthesizes AI’s efficiency with the rigor of formal methods, ensuring reliability in complex systems. Meyer emphasizes that iterative processes—similar to debugging—are essential, with AI aiding in both specification and verification phases. Tools like AutoProof and Dafny exemplify this integration, though challenges remain in tool usability and scalability. Good read!