Setting Up SQLite on Windows 11: A Guide for Developers

SQLite is a remarkable database engine—lightweight, serverless, and self-contained. Whether you’re building a small-scale project or need a quick, zero-configuration database for testing, SQLite is your go-to solution. But before diving into SQLite with Go or .NET on Windows 11, it’s crucial to understand how Windows 11 is set up by default and what tools you need to make your development environment rock-solid.

Windows 11 Default Setup: What You Need to Know

Windows 11 comes with some pre-installed tools and utilities, but when it comes to database work, you’re mostly on your own. The default setup lacks native support for databases like SQLite. Fortunately, Windows 11’s modern architecture and compatibility with a wide range of tools make it straightforward to configure.

Key Points of Windows 11 Default Setup:

  • PowerShell: Windows 11 ships with PowerShell, a powerful command-line shell that you’ll use frequently for installation and setup tasks.
  • Windows Subsystem for Linux (WSL): While not necessary for SQLite, WSL provides a Linux environment if you prefer to run SQLite commands in a Linux-like environment on Windows.
  • No Native Database Tools: Windows 11 doesn’t include any database management tools by default, so you’ll need to install SQLite manually.

Step 1: Installing SQLite on Windows 11

The first step in getting started with SQLite is to install it. Here’s how you can do that:

  1. Download SQLite Tools:
  • Visit the official SQLite Downloads page.
  • Under “Precompiled Binaries for Windows,” download the ZIP file containing the sqlite3.exe command-line shell.
  1. Extract and Place the Executable:
  • Extract the ZIP file to a directory of your choice, such as C:\sqlite.
  • Add this directory to your system’s PATH environment variable:
    • Right-click on This PC → Properties → Advanced system settings.
    • Click Environment Variables.
    • In the System variables section, find Path and click Edit.
    • Add the path to your C:\sqlite directory.
  1. Verify Installation:
  • Open PowerShell or Command Prompt.
  • Type sqlite3 and press Enter. You should see the SQLite command prompt, confirming the installation was successful.

Step 2: Setting Up Tooling for SQLite

To work effectively with SQLite, especially when managing complex databases or working on larger projects, you’ll need more than just the command-line tool.

  • DB Browser for SQLite:
    • A graphical interface for SQLite that simplifies database management.
    • Download from DB Browser for SQLite.
    • It provides an easy way to create, design, and edit SQLite databases.
  • SQLite Studio:
    • Another GUI tool that offers advanced features like SQL query generation and database schema visualization.
    • Download from SQLite Studio.

These tools are optional but highly recommended, especially if you’re new to SQLite or prefer a visual interface over command-line operations.

Step 3: Using SQLite with Go

If you’re working with Go, integrating SQLite into your project is straightforward. Here’s how to set it up:

  1. Install Go:
  • Ensure Go is installed. If not, download it from golang.org and install it.
  1. Install the SQLite Driver for Go:
  • Use the following command to install the SQLite driver: bash go get github.com/mattn/go-sqlite3
  • This driver allows you to interact with SQLite databases directly from Go.
  1. Write Your Go Code:
  • Here’s a quick example of using SQLite in Go:
package main

import (
    "database/sql"
    _ "github.com/mattn/go-sqlite3"
    "log"
)

func main() {
    db, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    _, err = db.Exec("CREATE TABLE IF NOT EXISTS example (id INTEGER PRIMARY KEY, name TEXT)")
    if err != nil {
        log.Fatal(err)
    }
}
  • This code snippet sets up a simple SQLite database and creates a table.
  1. Run Your Go Application:
  • Compile and run your application with go run yourfile.go. This will create an SQLite database named test.db in the current directory.

Step 4: Using SQLite with .NET

.NET provides excellent support for SQLite, allowing you to integrate it into your projects seamlessly. Here’s the setup:

  1. Install .NET SDK:
  1. Create a New .NET Project:
  • Create a new console or web application using the .NET CLI: bash dotnet new console -n SQLiteDemo cd SQLiteDemo
  1. Add the SQLite NuGet Package:
  • Install the Microsoft.Data.Sqlite package using the following command: bash dotnet add package Microsoft.Data.Sqlite
  1. Write Your .NET Code:
  • Here’s a quick example of using SQLite in a .NET application:
using Microsoft.Data.Sqlite;

class Program
{
    static void Main()
    {
        using var connection = new SqliteConnection("Data Source=sample.db");
        connection.Open();

        var command = connection.CreateCommand();
        command.CommandText =
        @"
            CREATE TABLE IF NOT EXISTS users (
                id INTEGER PRIMARY KEY,
                name TEXT
            )
        ";
        command.ExecuteNonQuery();
    }
}
  1. Run Your .NET Application:
  • Compile and run your application with dotnet run. This will create an SQLite database named sample.db in the current directory.

Warp Up

Setting up SQLite on Windows 11 is easy with the right steps. Whether you’re working with Go, .NET, or another language, SQLite’s versatility makes it an excellent choice for a wide range of projects. With this guide, you’re well on your way to leveraging SQLite’s power in your development workflow on Windows 11.

Self-Inflicted Shortage: How Poor Leadership and Practices in Large Companies (specifically FAANG like companies) Created a Developer Crisis

I’ve been wanting to write up a few thoughts on the ever ongoing “labor shortage” and “talent shortage” that big companies often cite. Especially in regards to expanding H1B use (albeit arguably exploitive in the way its often used) all the while damning existing labor. The following are some collected observations of the tech industry. It seems timely considering the number of people, qualified people, looking for work right now. All while still citing a shortage when it is pretty clear there is not a shortage of qualified people.

The Self-Inflicted Wound of Talent Shortages: A FAANG Case Study

The tech industry, and more specifically the FAANG giants (yes, I’m sticking with that acronym despite its recent evolutions), has long been heralded as the pinnacle of innovation and progress. But, beneath the shiny exterior, there’s a glaring problem that’s both self-inflicted and entirely avoidable: a severe shortage of good software developers. This isn’t because there’s a lack of talent out there—far from it. It’s because of poor leadership, short-sighted hiring practices, and a failure to nurture and retain the talent that these companies already have.

Burnout and Turnover: The Tech Industry’s Revolving Door

Let’s call it what it is: FAANG companies, and their countless imitators and offshoots, have a problem with how they manage their workforce. They’ve turned what should be an asset—their employees—into a disposable resource. Rather than investing in the growth and development of their teams, they chew through talent at an alarming rate. This burnout machine not only depletes their own ranks but also sends shockwaves through the entire industry, making it harder for other companies to find and keep good developers.

Here’s how it goes down: instead of cultivating a culture of continuous learning and professional growth, these companies opt for the short-term gains of high-pressure environments. The inevitable result? Massive turnover. The few who do manage to thrive in such a setting often find themselves undervalued, eventually moving on to greener pastures—if they don’t burn out first. And so, the cycle continues.

The Hyper-Competitive, Salary-Driven Vicious Cycle

In response to this revolving door of talent, what do these companies do? They throw money at the problem. Salaries in FAANG have skyrocketed, with compensation packages reaching absurd levels—$250k, $400k, and in SF or Seattle, sometimes far beyond that (think $600k as a base total comp package for senior/top talent). But, here’s the kicker: this hasn’t solved the problem. It’s merely masked it.

Rather than addressing the toxic work environments that drive people away, these companies have tried to buy their way out. New hires are lured in with promises of wealth, only to be ground down and replaced by the next wave of recruits. It’s a vicious, unsustainable cycle, driven by poor leadership and a fundamental misunderstanding of what keeps people engaged and productive in the long run.

Exploiting Immigrant Talent: The H1B Band-Aid

And then there’s the H1B visa program. Originally designed to bring in skilled workers where there’s a genuine need, it’s now being used as a band-aid for poor workforce management. FAANG companies exploit this system, bringing in talent from abroad under the guise of providing opportunities, only to subject these workers to the same burnout-prone environment that domestic employees face.

For many of these workers, their visa status ties them to their employer, making it difficult—if not impossible—to leave, even if they want to. This is exploitation, plain and simple. It not only harms the individuals involved but also tarnishes the industry’s reputation, making it even harder to attract and retain talent.

Summary of The Crisis

The tech industry’s talent shortage is not a result of a lack of skilled developers, but rather a consequence of poor management practices, toxic work environments, and short-term thinking. FAANG companies, in particular, have created a vicious cycle of burnout and turnover – exacerbated by stack ranking (more on that in the future) – by failing to invest in their employees’ growth and relying on unsustainable salary inflation to mask deeper issues. The exploitation of immigrant talent through the H1B visa program further exacerbates the problem, damaging both the industry’s reputation and its ability to retain talent. To break this cycle, tech leaders must prioritize creating supportive, growth-oriented cultures that value long-term employee engagement over short-term gains. Only by addressing these fundamental issues can the industry hope to build a sustainable future where innovation thrives alongside a healthy and motivated workforce.

Transform Your 1:1 Meetings: From Status Reports to Meaningful Conversations

Let’s face it—1:1s often feel like a chore. They can seem awkward, unnecessary, or even stressful, especially if they devolve into nothing more than a glorified status report. These meetings are supposed to be about meaningful dialogue, yet too often, they become just another checkbox on the to-do list. If you’ve ever found yourself reciting project updates that could’ve been sent in an email, you’re not alone.

But here’s the thing—when 1:1s turn into status reports, they lose their value. And that’s a big problem for several reasons:

  1. Missed Opportunities Turning 1:1s into routine updates means missing out on the chance to discuss your personal growth, career aspirations, or challenges that need attention. This time is carved out for your development and support. If you’re not using it wisely, you’re letting potential progress slip through your fingers.
  2. Lack of Connection When your 1:1s are all about status updates, you miss the opportunity to build a deeper connection with your manager. Understanding your manager’s goals and challenges is key to aligning your work with the broader mission of the team and company. Without this connection, you risk becoming isolated, working on tasks that don’t fully align with the bigger picture.
  3. Increased Frustration If 1:1s feel like just another meeting to get through, they become something you dread rather than look forward to. When these meetings lack substance, they turn into a time-waster, leading to frustration and disengagement.

So, how do you change the dynamic? How do you make 1:1s less cumbersome and more valuable for both you and your manager? Here’s how to flip the script:

Make Your 1:1s Count:

  1. Ask for What You Need Use your 1:1s to ask for the resources or support that will help you grow. Need career advice? Ask for it. Facing a roadblock? Seek help to get unblocked. Want to meet someone influential in your field? Request an introduction. This is your time—make sure you’re using it to your advantage.
  2. Understand Your Manager’s World Instead of just sharing your progress, take the time to ask your manager about their challenges and goals. What’s their biggest concern right now? What are they focusing on? Understanding what’s on your manager’s mind can help you better align your efforts with the team’s priorities, making you a more effective and valuable team member.
  3. Learn About the Business 1:1s are an excellent opportunity to get a deeper understanding of the business. Ask about the company’s growth areas, the challenges it’s facing, and where your work fits into the bigger picture. Having this insight not only makes you more informed but also more strategic in your contributions.
  4. Seek Feedback Regularly Don’t wait for annual reviews to get feedback on your performance. Use your 1:1s to ask for continuous feedback. What are you doing well? Where can you improve? Regular feedback helps you course-correct quickly and ensures you’re always moving in the right direction.
  5. Discuss Long-Term Goals Use your 1:1s to discuss your long-term career goals. Where do you see yourself in a year or five years? What steps can you take now to get there? This helps ensure your day-to-day work aligns with your broader career aspirations and keeps you motivated.

For Managers:

As a manager, your role in 1:1s is crucial. If you’re not careful, these meetings can easily become stale and unproductive. Here’s how to ensure they stay valuable:

  1. Foster Openness Create an environment where your team feels comfortable discussing more than just their work progress. Encourage them to bring up their challenges, ask questions, and share their career aspirations. This openness builds trust and helps you better support your team.
  2. Share Your Perspective Be transparent with your team about your own challenges and objectives. This helps your team understand the context behind decisions and aligns their efforts with the company’s goals. Transparency also makes these meetings more engaging and less about checking boxes.
  3. Focus on Growth Your 1:1s are an opportunity to mentor and guide your team. Use this time to help your team members grow, providing the resources and support they need to advance in their careers. When your team thrives, so do you.
  4. Set Actionable Goals Work with your team members to set clear, actionable goals during your 1:1s. These goals should be specific, measurable, and aligned with both their personal development and the team’s objectives. Setting and tracking progress on these goals gives your 1:1s direction and ensures they’re driving real impact.
  5. Provide Regular Feedback Make feedback a regular part of your 1:1s. Don’t wait for formal reviews to give your team members insights into their performance. Regular, constructive feedback helps them improve and stay aligned with the team’s goals. It also shows that you’re invested in their development.
  6. Create a Safe Space for Honest Dialogue Encourage your team to speak openly and honestly in 1:1s. Let them know that this is their time to share what’s on their mind without fear of judgment. Creating a safe space for dialogue ensures that issues are addressed early and that your team feels heard and supported.

Conclusion:

1:1s don’t have to be a burden—they can be one of the most powerful tools for growth and connection in your work life. By shifting the focus from status reports to meaningful conversation, you’ll find these meetings become not only more productive but also more engaging and rewarding.

What strategies have worked for you in making the most out of 1:1s? Let’s share and learn from each other—drop your thoughts below! 👇

Azure Arc: Unified Management for Hybrid and Multi-Cloud Environments

I’ve been deep in the trenches of multi-cloud tooling for years now, exploring everything from Kubernetes to Terraform, and all the glue that holds modern infrastructures together. Recently, I took a deep dive into Azure Arc, Microsoft’s hybrid and multi-cloud management solution, to see what it brings to the table. What follows is a breakdown of Azure Arc, framed through the lens of someone who’s seen the evolution of these tools over time.

The Core Idea Behind Azure Arc

At its core, Azure Arc is Microsoft’s answer to the complexities of hybrid and multi-cloud management. The idea is simple yet powerful: provide a unified management experience for resources, regardless of where they live. Whether you’re running workloads on-premises, across different cloud providers, or out on the edge, Azure Arc aims to bring them all under a single, cohesive management umbrella.

What Azure Arc Really Does

Azure Arc extends Azure’s management capabilities beyond its own boundaries. Think of it as a bridge that connects your existing infrastructure to Azure’s powerful tools and services. Once your resources are “Arc-enabled,” you can manage them just like you would any native Azure resource. This means applying policies, leveraging Azure’s security features, and using monitoring tools – all from within the Azure portal.

The beauty of Azure Arc is that it doesn’t discriminate based on where your resources are. Whether it’s a Linux server running in your own datacenter, a Kubernetes cluster on Google Cloud, or even a SQL database on AWS, Azure Arc brings it all together. This isn’t just about management, though. Azure Arc also allows you to deploy Azure services, like SQL and PostgreSQL Hyperscale, directly into your non-Azure environments.

Azure Arc for Kubernetes

Azure Arc’s support for Kubernetes is where things get particularly interesting. If you’re managing Kubernetes clusters across different environments—whether it’s AKS, EKS on AWS, GKE on Google Cloud, or even an on-premises setup—Azure Arc brings these disparate clusters into the fold under Azure’s management.

With Azure Arc, you can attach your Kubernetes clusters to Azure, enabling you to deploy applications consistently across all your clusters using GitOps, apply consistent security and governance policies, and even monitor and manage them from the Azure portal. This is incredibly powerful in multi-cloud environments where you might have clusters spread across different platforms but need a unified approach to management and operations.

The integration with AKS is seamless, of course, but the real power lies in Azure Arc’s ability to connect with other cloud providers’ Kubernetes offerings. Whether you’re dealing with AWS’s EKS, GCP’s GKE, or a custom Kubernetes setup, Azure Arc enables a level of control and consistency that can be a game-changer in complex, hybrid environments.

Defining Azure Arc

Azure Arc is, in essence, a set of technologies that extend Azure’s control plane to wherever your resources reside. Here’s what it means in practice:

  • Unified Server Management: You can connect and manage your Windows and Linux servers across on-premises, edge, and multi-cloud environments from a single pane of glass within Azure.
  • Kubernetes Cluster Integration: Azure Arc allows you to attach and manage Kubernetes clusters from anywhere. This means consistent management, monitoring, and governance across your entire Kubernetes estate, regardless of where those clusters are running.
  • Data Services Anywhere: With Azure Arc, you can run Azure’s data services, like Azure SQL and PostgreSQL Hyperscale, in any environment. This gives you the flexibility to use Azure’s data capabilities wherever you need them most.
  • Consistent Governance and Security: Perhaps one of the biggest wins here is the ability to enforce compliance and governance policies consistently across all your resources, no matter where they’re deployed.

In short, Azure Arc is Microsoft’s play to bring coherence and control to the sprawling, often chaotic, world of hybrid and multi-cloud environments. It’s a tool that’s not just about visibility but about giving you the power to manage, secure, and optimize your entire infrastructure from a single point of control. And in a world where resources are scattered across different platforms and locations, that’s a game-changer.

Further Reading and Viewing on Azure Arc

If you’re interested in diving deeper into Azure Arc and particularly how it integrates with Kubernetes across various environments, there are a few must-see resources:

  1. **[Azure Arc-enabled Kubernetes Extensibility Model Azure Friday](https://www.youtube.com/watch?v=2HSuzHEQDGw)** – In this video, Scott Hanselman and Lior Kamrat discuss how Azure Arc enables Kubernetes clusters outside of Azure to be managed and governed like native Azure resources, complete with demos.
  2. **[Azure Arc-enabled Kubernetes with GitOps Azure Friday](https://learn.microsoft.com/en-us/shows/azure-friday/azure-arc-enabled-kubernetes-with-gitops)** – This session delves into how Azure Arc uses GitOps to manage Kubernetes clusters across various environments, showcasing how to maintain a single source of truth through GitHub repositories.
  3. **[Building Modern Hybrid Applications with Azure Arc and Azure Stack Azure Friday](https://learn.microsoft.com/en-us/shows/azure-friday/building-modern-hybrid-applications-with-azure-arc-and-azure-stack)** – Thomas Maurer joins Scott Hanselman to demonstrate how to build and manage hybrid applications across multiple environments using Azure Arc, including a demo of Kubernetes integration.

These resources provide a comprehensive look at how Azure Arc can be integrated into your multi-cloud strategy, particularly if Kubernetes is part of your infrastructure mix.

Effective Developer Advocacy: Prototyping, Open Source, Community Building

Having worked specifically in Developer Advocacy in the past, I have well-formed opinions about how it should work and some data-driven insights into what makes Developer Advocacy effective. My experiences and observations have led me to a clear vision of what I’d like to see in DevRel teams and, more specifically, from developer advocates as a sometimes fellow developer advocate and an all the time software solutions developer/engineer/etc.

Prototyping and Problem-Solving

One of the primary areas where Developer Advocates (DAs) can shine is by creating prototype applications that tackle specific problems. Regardless of their experience level, DAs should be hands-on with the technology they are advocating for. For instance, a Developer Advocate focused on logging should dive deep into tweaking logging mechanisms. This could involve demonstrating advanced configurations, optimizing log formats for better readability, or integrating logging frameworks with monitoring tools.

For security-focused DAs, I’d make the case that attention to detail should be even more pronounced. They should not only explain the fundamentals of OAuth implementations or JWT tokens but also delve into the details that often trip up developers and be familiar – in general – with the infosec area of the industry. For example, demonstrating best practices for token storage, handling token expiration, and ensuring secure communication channels and why you should do these things would be immensely valuable.

Contributions to Open Source

Another critical aspect of an effective DevRel team is active participation in Open Source Software (OSS) projects. Developer Advocates should regularly contribute to OSS, not just through code but also by writing articles and creating content that highlights their experiences. Sharing what works, what doesn’t, and the lessons learned during these contributions can provide invaluable insights to the broader community.

Imagine a DA working on integrating two popular tools. Documenting the journey—right from initial setup, through the challenges faced, to the final implementation—can serve as a roadmap for others attempting the same. Articles that cover these real-world integrations, the hurdles encountered, and the solutions devised would be a treasure trove of knowledge for developers worldwide. They’re something, that often, is simply not available. When they are, they’re often short, rudimentary, and rarely offer insight beyond the simple happy path.

The Right Amount of Travel

I am generally supportive of the operational situation, backed by data, that Developer Advocates should keep travel engagements to around 10-25% of their work. Excessive travel—anything more than 25%—is a red flag for several reasons. These aren’t reasons I’m just making up either, because I have seen some advocates manage excessive travel pretty well, but the vast majority of people just simply don’t have the bandwidth and ability to mitigate the risks:

  1. Disruption to Focused Work: Traveling takes most Developer Advocates away from focused work on building prototypes, learning a technology, or exploring tangential aspects of what they’re advocating for.
  2. Loss of Technical Expertise: It starts the process of pulling an advocate away from their technical expertise and focus time, causing a lapse in hands-on technical work.
  3. Perception of Detachment: This can perpetuate the idea that many Developer Advocates don’t really work with the tech or have a solid understanding of what they’re advocating.
  4. Erosion of Credibility: Building on the previous points, this tends to render an advocate’s reputation useless in working as an engineer/developer/programmer, as people become highly doubtful of their technical acumen.

Building Community Through Collaboration

Effective DevRel is not a solo endeavor; it thrives on collaboration. Developer Advocates should foster a sense of community by working together on projects, sharing knowledge, and supporting each other’s efforts. They should write articles and create content that speaks to their experiences of working together. Highlighting what tools and techniques that mix well and identifying common problem points can pave the way for more streamlined development processes, spearheaded by developer advocates showing exactly how to do this at a tactical level.

For example, a series of blog posts or videos where DAs from different specialties come together to build a cohesive application can be incredibly insightful. For example at Amazon, seeing a security DA work alongside a logging DA and a front-end DA (do those exist at Amazon?) to tackle a comprehensive project would not only showcase their individual expertise but also their ability to collaborate and create a unified solution.

Improving DevRel

In my humble opinion, there are several ways DevRel can improve and amplify its impact:

  1. Hands-on Demonstrations: More live coding sessions, webinars, and workshops where DAs build and troubleshoot applications in real-time. This hands-on approach makes the learning process more tangible and relatable.
  2. Transparency in Learning: Sharing not just successes but also failures and lessons learned. This transparency can demystify the development process and make it more accessible to developers at all levels.
  3. Inclusive Contributions: Encouraging contributions from developers of all backgrounds and experience levels. This inclusivity can lead to a richer, more diverse set of solutions and ideas.
  4. Focused Content: Creating content that addresses specific, granular aspects of development. Whether it’s a deep dive into a niche feature of a logging tool or an in-depth guide on securing OAuth implementations, focused content can provide deep insights that broad overviews often miss.
  5. Collaborative Projects: Promoting and participating in cross-functional projects that bring together DAs from different domains. This collaboration can lead to more holistic and robust applications and tools.

In conclusion, Developer Advocates play a pivotal role in bridging the gap between technology and the developer community. By focusing on hands-on prototyping, active OSS contributions, and fostering collaboration, DevRel teams can significantly enhance their effectiveness. Transparency, inclusivity, and a commitment to continuous learning will ensure that DevRel not only keeps pace with the rapidly evolving tech landscape but also helps shape its future.

Note! All of these points, I’m absolutely open to debate about. This is my findings, there are a limited number of studies around this topic, and I’m more than happy to change my mind based on new data! If you’ve got any data or a different take on any of these points, I want to hear them! Let’s get a conversation going over at @Adron on Mastadon or Threads or LinkedIn!