Hackathons have become synonymous with innovation and collaboration, serving as a launchpad for creative problem solving, community building, and professional growth. Hackathons consistently prove their ability to drive both technological advancements and lasting social impact. Iconic events including TreeHacks, Cal Hacks, ETHGlobal, Hacktoberfest, Social Winter of Code, and JPMorgan Chase’s Code for Good Hackathon further highlight their potential to empower communities and inspire meaningful change.

Here’s why your organization should host a hackathon—and how to make it a resounding success.

1. Foster Innovation and Solve Real-World Problems

Hackathons are engines of innovation, pushing participants to think creatively and deliver actionable solutions under time constraints. Whether it’s building cutting-edge blockchain protocols or revolutionary app features, hackathons inspire ingenuity that can redefine industries.

For instance, ETHGlobal has become synonymous with Web3 innovation. By hosting hackathons that provide resources, mentorship, and a focused environment, ETHGlobal enables participants to develop decentralized apps, blockchain tools, and other transformative technologies. These events showcase how hackathons deftly solve challenges and explore emerging technologies, resulting in tangible, impactful outcomes.

Hosting a hackathon enables you to channel creative energy within your team or community to tackle industry-specific challenges, leverage innovative technologies, and potentially create groundbreaking solutions.

2. Attract and Retain Talent

Hackathons are the perfect stage to discover and engage with top-tier talent, allowing you to see participants’ problem-solving skills in action.

Prestigious events such as Cal Hacks and TreeHacks consistently attract the brightest minds, giving companies an invaluable opportunity to connect with skilled developers, engineers, and designers. Many organizations use hackathons as a talent pipeline, identifying future employees who demonstrate creativity, resilience, and teamwork.

By hosting a hackathon, you showcase your organization as an innovation leader while also connecting with potential collaborators, contributors, or hires in a natural, high-energy setting.

3. Drive Impact and Elevate Your Brand

Hackathons can create both social impact and brand visibility, solidifying your organization’s role as a leader in innovation and responsibility.

For example, JPMorgan Chase’s Code for Good Hackathon focuses on designing solutions for nonprofit organizations, attracting participants passionate about making a difference to address real-world issues.

A well-executed hackathon elevates your brand while making a meaningful impact, demonstrating your commitment to innovation, responsibility, and community engagement.

4. Build Community and Inspire Collaboration

Hackathons give diverse groups of individuals the opportunity to come together, collaborate, and solve complex challenges as a team.

Events like Hacktoberfest and Social Winter of Code stand out for their ability to foster deep connections among participants. By pairing developers, designers, and product managers from different backgrounds, these hackathons enable holistic approaches to problem solving while building a sense of community that lasts long after the event ends.

Hosting a hackathon strengthens your community, attracts new contributors, and provides a space for interdisciplinary collaboration that sparks innovative ideas.

How to Host an Unforgettable Hackathon

Hosting a hackathon requires thoughtful planning and execution to maximize impact and engagement. Here’s how to ensure that your event stands out:

1. Define a Clear Purpose

Every successful hackathon starts with a well-defined goal:

• Do you want to tackle a specific challenge in your industry?

• Are you looking to build a stronger community?

• Is your aim to attract top talent or explore new technologies?

Aligning your event’s purpose with your organization’s broader objectives helps focus your efforts and attract the right participants.

2. Plan Your Event

Decide how you want to host your event: in-person, online, or hybrid. Each comes with pros and cons:

• In-person events foster direct collaboration and networking but require logistical planning such as venue setup and travel arrangements.

• Online events are more accessible and cost-effective but may lack the energy and immediacy of in-person interactions.

• Hybrid events offer the best of both worlds but can be complex to execute seamlessly.

To help you streamline hackathon logistics, platforms like Devfolio, Major League Hacking, and Devpost simplify participant registration, project submissions, and judging. These tools save organizers valuable time and effort while ultimately enhancing the participant experience.

3. Engage Participants With Incentives

Incentives like prizes, recognition, and mentorship are critical to promoting participant motivation and energy throughout the event.

• Offer both tangible rewards (cash prizes, swag, or tools) and intangible recognition (resume-building opportunities).

• Platforms such as Vaunt provide shareable badges/certification and recognition, making every participant feel valued.

4. Create a Supportive Environment

A successful hackathon is more than just a competition—it’s an experience.

• Mentorship: Provide access to mentors who guide participants and help them overcome roadblocks.

• Workshops: Offer skill-building sessions before or during the event to prepare participants and maximize the quality of submissions.

• Resources: Ensure that participants have access to the tools, APIs, and documentation needed to succeed.

5. Highlight and Celebrate Achievements

Recognition is key to building lasting goodwill.

• Highlight standout projects during the event’s closing ceremony or in post-event communications.

• Use social media and blogs to showcase top teams and their solutions.

• Offer participants a platform, such as Vaunt, to showcase their contributions and share their achievements with the broader community.

6. Promote Collaboration and Networking

Encourage participants to form diverse teams and engage with others beyond their immediate circles.

• Facilitate networking opportunities, such as virtual meetups or in-person icebreakers.

• Use collaboration tools (e.g., Discord or Slack) to keep communication flowing smoothly.

7. Follow Up After the Event

The impact of your hackathon shouldn’t end when the last team presents their solution.

• Stay in touch with participants through newsletters or follow-up emails.

• Share outcomes, such as notable projects or metrics, to keep the momentum alive.

• Offer continued engagement opportunities: long-term mentorship, open-source contributions, or invitations to future events.

Conclusion: Build the Future With Hackathons

Hosting a hackathon is more than just an event—it’s a launchpad for innovation, collaboration, and lasting growth. From Facebook’s Like button to the groundbreaking blockchain protocols developed at ETHGlobal and global contributions celebrated by Hacktoberfest, hackathons have proven their ability to spark transformative ideas and solve real-world challenges.

By thoughtfully planning your event, leveraging tools like Vaunt, Devfolio, or Devpost to streamline workflows and reward participants, and fostering an environment of mentorship and creativity, your hackathon will create an unforgettable experience with a lasting impact.

Ready to unlock your organization’s full potential? Start planning your hackathon today and join the ranks of innovators shaping the future. 🚀

👉 Learn how Vaunt can help you create an engaging, rewarding hackathon experience.

But hackathons aren’t just for experienced developers—they’re also perfect for beginners. Whether you’re attending your first hackathon to learn, build, or network, 2025 is the perfect year to get started. This guide will help you prepare for your first hackathon, navigate the event, and maximize the exciting opportunities these events offer.

Before the Event: Prepare Like a Pro

Understand the Event Format

Hackathons can take place in-person, online, or hybrid. Check the event’s theme, schedule, and rules to know what to expect.

Pack the Essentials

• For in-person events: Bring your laptop, chargers, headphones, snacks, and a reusable water bottle.

• For online events: Ensure a stable internet connection and quiet workspace.

Build or Join a Team

Many hackathons let you form teams in advance. Choose teammates with complementary skills, e.g., developers, designers, and product managers.

Brush Up on Relevant Skills

Review the tools, APIs, or programming languages you might use. Many hackathons also offer pre-event workshops—take advantage of these!

During the Event: Work Hard, Have Fun

Hackathons are fast-paced but incredibly fulfilling. Here’s how to thrive:

Brainstorm

• Focus on solving a specific problem that excites your team.

• Keep project scope realistic for the time available.

Communicate Effectively

• Use tools like Slack or Discord to stay connected with your team.

• Divide tasks based on strengths, and sync up regularly to stay aligned.

Stay Energized

• Food and hydration: Snack regularly, drink water, and fuel up with nutritious meals.

• Rest and breaks: Take breaks every few hours to refresh your mind and avoid burnout.

Manage Your Time

• Create a timeline for your project, breaking tasks into manageable chunks.

• Try methods such as the Pomodoro Technique to stay productive.

Make It Fun

Enjoy the process! Participate in mini-games, social events, and networking sessions offered by the organizers.

After the Event: Celebrate and Share

Showcase Your Work

Present your project confidently during the demo or submission phase, even if it’s a prototype. Hackathons value creativity and effort as much as completion.

Reflect on Your Experience

What did you learn? What could you improve next time? Who did you meet?

Share Your Achievements

Use platforms like Vaunt to showcase your work with Developer Cards or highlight your badges for milestones achieved during the hackathon. Vaunt connects you with the broader developer community and proudly exhibits your contributions, turning your hard work into tangible career assets.

Continue the Momentum

• Polish your project, then publish it on GitHub or an open-source repository.

• Stay connected with your team and mentors for future collaborations.

Your First Hackathon Awaits!

Your first hackathon is more than just an event—it’s a chance to learn, create, and grow in a fun and supportive environment. Start by exploring upcoming hackathons through resources like Major League Hacking (MLH) or Devpost, and get ready to make your mark.

And remember, tools like Vaunt can make your journey even more rewarding by recognizing your achievements and connecting you with like-minded developers. Whether you’re solving problems, making new friends, or earning your first badge, your hackathon experience is something to celebrate!

So, what are you waiting for? Sign up for a hackathon today, and let your creativity shine!

Why Vaunt Is Perfect for Hackathons

Vaunt enhances your hackathon experience by providing gamified badges for milestones like First Commit or Top Project. These badges are shareable on GitHub, Linkedin, and Vaunt profiles, making it easy to showcase your achievements and stand out in the developer community.

Together, we’re introducing exciting new achievements to recognize and reward developers for their contributions. Whether you’re a seasoned contributor or new to open source, this partnership is designed to celebrate your efforts, amplify your achievements, and connect you with a thriving community.

What Is Serverpod?

Serverpod is the ultimate backend framework built by and for the Flutter community, written entirely in Dart. It’s a powerful platform that streamlines backend development for modern Flutter applications, offering seamless integration with Flutter, robust database support, and effortless API creation. With Serverpod, building scalable, real-time applications becomes a breeze.

https://x.com/ServerpodDev/status/1849761404376470009

For developers passionate about Flutter and Dart, Serverpod is your perfect playground for backend innovation. Designed with the same care and precision as Flutter itself, it empowers you to create efficient, user-focused backends with ease. By contributing to Serverpod, you’re helping to shape this cutting-edge framework while contributing to the broader open-source community, making backend development more accessible and powerful for all Flutter developers.

With a vibrant and fast-growing community, regular updates, and a commitment to open collaboration, Serverpod offers contributors the chance to make a real impact. Dive in and join the movement that’s shaping the future of backend development for Flutter!

What Does the Vaunt + Serverpod Partnership Mean for You?

In partnership with Serverpod, Vaunt offers exciting ways to reward and celebrate your engagement:

• Achievement Cards: Earn shareable, visual tokens that recognize your contributions and milestones, from starring the repository to merging pull requests to reporting issues. Each badge tells a story of your impact and helps inspire others.

• Developer Cards: Build your reputation with a personalized profile that showcases your contributions, skills, and accomplishments within the community.

• Notification Bot: Stay connected with real-time updates and shoutouts for your achievements through Serverpod’s GitHub Discussions. This bot ensures that you’re always informed about your progress and how to unlock new badges.

• Vaunt Open Source Community: Connect, collaborate, and share expertise with like-minded developers in an active and growing ecosystem.

With every step, you’ll earn recognition for your efforts—while supporting a project that’s shaping the future of backend development.

What Achievements Can You Earn?

Serverpod’s achievement system features 20 unique badges, each designed to recognize a variety of contributions and milestones. These badges go beyond simple rewards—they’re a powerful way to highlight your skills, track your impact, and gain recognition within the community. Getting started is easy: Star the repository, dive into open issues, and make your first contribution to begin earning achievements. Here are a few examples:

• Art Nouveau: Honoring early supporters of Serverpod’s first release (1.0), this badge celebrates contributors who had pull requests merged before February 15, 2023

• Galactic Guardian: A badge for dedicated developers who successfully merge 25 pull requests, showcasing their commitment to Serverpod’s growth

• Quantum Questioner: Awarded to those who help uncover and report 100 issues labeled as bugs or enhancements, demonstrating a critical eye for quality

With each badge, Serverpod shows its appreciation for contributors from all stages—whether you’ve been there from the beginning or are just diving in today to leave your mark. This is just the beginning: Serverpod plans to introduce even more achievements in future releases, ensuring continuous opportunities to engage and celebrate.

We encourage you to explore these badges and review your progress on the Serverpod achievement board, where your contributions take center stage. Once you unlock a badge, don’t forget to share it on social media to showcase your contribution and inspire others!

How to Contribute to Serverpod

Getting involved with Serverpod is simple, rewarding, and an excellent way to make an impact on the open-source community. Follow these steps to start contributing:

Step 1: Star the Repository

First off, show your support by starring the Serverpod GitHub repository. This helps boost the project’s visibility and connects you with an active community of contributors. Plus, it’s your first step toward earning an Achievement Badge for supporting open-source innovation.

Step 2: Explore the Project

Take some time to familiarize yourself with Serverpod’s documentation, codebase, and existing issues. Understanding the project’s goals and structure makes it easier to identify where you can contribute.

Check out the Vaunt achievement board to see what badges are available and set goals for your contributions.

Step 3: Pick an Issue and Get Started

Browse the Issues tab on GitHub and look for open issues. If you’re new to contributing, look for issues labeled good first issue or help wanted—these are great starting points.

Have an idea for an improvement or feature? Feel free to open a new issue and discuss it with the maintainers.

Step 4: Join Discussions and Collaborations

Engage and join community discussions in the GitHub Discussions tab to share your ideas, ask questions, or seek feedback on your contributions. The community is welcoming and ready to support you!

Join Us on This Journey

We invite developers, contributors, and open-source enthusiasts to explore Serverpod, contribute to its development, and earn recognition for their efforts. Whether you’re solving issues, adding features, or helping refine the project, your contributions make a lasting impact.

Serverpod needs developers like you to shape its future. Start by starring the GitHub repository, exploring open issues, and joining the community today.

Remember to follow Vaunt on X or join our Discord to stay updated and share your feedback.

Every contribution makes a difference! Start your journey with Serverpod today and become part of a project that’s transforming backend development.

Vaunt’s GitHub Wrap is a personalized year-end summary for developers, offering the opportunity to reflect on your GitHub journey and share accomplishments with peers, potential employers, and the developer community. Let’s dive into why this tool is perfect for wrapping up your 2024.

Why Developers Should Use Vaunt’s GitHub Wrap

1. Showcase Your Contributions
   Whether you’re a contributor to major open-source projects or working on side projects, Vaunt helps you present your efforts. Highlight your pull requests, issues resolved, repositories launched, and other key contributions in a way that resonates with the developer community.

2. 

   Boost Your Online Profile
   Looking to stand out in the job market or build your online developer portfolio? Sharing your GitHub Wrap is a unique way to highlight your experience and accomplishments. Add it to your GitHub profile and portfolio, or share it on LinkedIn and social media to showcase your expertise.

3. Celebrate Your Journey
   Coding is a journey filled with learning, growth, and achievements. With Vaunt’s GitHub Wrap, you can reflect on your progress throughout the year, celebrate what you’ve accomplished, and set new goals for the upcoming year.

   

4. Engage With the Community
   Your wrap isn’t just a personal achievement—it’s a conversation starter. Engage with other developers by sharing your wrap, learning about their journeys, and building connections based on shared experiences and contributions.

   

How It Works

Creating your Developer GitHub Wrap is quick and easy:

• Enter your GitHub username on our platform

• Vaunt retrieves your public contribution data from GitHub, including commits, pull requests, issues, and more

• The data is transformed into a visually appealing and shareable SVG wrap, perfect for sharing on social media, GitHub, and developer communities

Your wrap highlights everything from the number of commits you made to pull requests you opened and merged to the repositories you contributed to—and more. It’s a complete snapshot of your year in code!

Get Started with Vaunt’s Developer GitHub Wrap Today

As the year draws to a close, it’s time to celebrate your hard work! Generate your GitHub Wrap today and share your accomplishments with the world.

🔗 Create Your GitHub Wrap Now!

Looking Ahead to 2025

As you continue your journey over the rest of 2024, Vaunt is right by your side to help you track your achievements and celebrate your contributions. Stay tuned for even more insights and features as we move forward into 2025!

Discover More With Vaunt

Engage with your community through Developer Cards, Achievement Cards, Vaunt Open Source Communities, and more.

Stay connected with us for updates and feature releases. Join our Discord or follow us on X to stay in the loop.

🔗 Visit Vaunt’s GitHub Wrap to generate your organization’s wrap.

Why Use Vaunt’s GitHub Wrap to Close Out 2024?

1. Highlight Community Achievements: Showcase your team’s contributions across GitHub, including repositories created, issues resolved, and pull requests merged. Turn your data into a story of progress.

2. Engage Your Community: Share your GitHub Wrap with stakeholders and the wider developer community. Foster deeper engagement by celebrating collective success and inspiring ongoing contributions in 2024.

3. Prepare for 2025: Vaunt’s Wrap is not just a year-end summary—it’s also a tool for continuous growth. As 2025 approaches, use the insights to set benchmarks and gear up for another productive year!

How It Works

Creating your Organization GitHub Wrap is simple:

• Enter your GitHub organization name on our platform

• Vaunt uses the public GitHub API to collect key data from your repositories

• The data is transformed into a visually stunning wrap highlighting your key metrics and contributions over the past year

With Vaunt’s GitHub Wrap, you get more than numbers—you get a celebration of your journey and a chance to inspire future contributions. Your wrap is perfect for sharing via social media, community forums, or internal showcases to highlight your team’s efforts.

Why Choose Vaunt?

Vaunt’s GitHub Wrap for organizations offers much more than a year-end summary:

• Build Recognition: Showcase your organization’s impact within the open-source ecosystem, helping you attract skilled contributors and maintainers

• Engage Beyond Statistics: Highlight the collaborative spirit behind your project and build a stronger community

• Create Individual Wraps: Invite developers within your organization to generate personal wraps to share their individual contributions and achievements across social platforms

Looking Forward to 2025

As we look ahead to 2025, Vaunt’s Organization GitHub Wrap will continue to evolve, providing even deeper insights and recognition for organizations and contributors alike. Join Vaunt today to set the tone for a productive 2025 and prepare for a year of growth and innovation.

🔗 Generate your Organization GitHub Wrap today!

Discover More With Vaunt

Further engage with your community through Achievement Badges, Contributor Cards, and Vaunt Open Source Communities; by hosting hackathon management and hero programs; and more.

Sign up for Vaunt today to boost engagement and recognition across your projects!

Platforms such as Vaunt.dev make it easier to spotlight open source contributors by gamifying recognition. Vaunt provides tools to highlight all contributions, fostering a sense of belonging and motivating developers to contribute more.

Why Recognition Is Crucial

1. Encourages Consistency: Acknowledging contributors ensures that they feel valued, motivating them to continue working on the project. Open source thrives on consistent engagement, for which recognition becomes a vital driver.

2. Attracts New Talent: New contributors often hesitate to join open source projects due to imposter syndrome. By spotlighting all contributors, from junior developers to experienced engineers, you encourage inclusivity and make the community more approachable.

3. Promotes Diversity in Contributions: Contributions like bug reports, testing, or documentation often don’t get the level of recognition that code contributions do. Recognizing these non-code efforts brings balance to the community and ensures that essential yet often overlooked tasks are appreciated.

How Vaunt Supports Contributor Recognition

Recognizing open source contributors is more than just a gesture of appreciation—it is essential for sustaining a project’s energy, collaboration, and diversity. When contributors, particularly those involved in non-code tasks, feel acknowledged, they are motivated to continue participating and invite others to join the community.

Vaunt.dev offers tools to quantify and celebrate contributions—including bug fixes, mentorship, and documentation—across all open source projects. By gamifying recognition, the platform incentivizes contributors and helps maintain vibrant, engaged communities. This structured acknowledgment helps boost morale and long-term project success.

Contributor recognition ensures sustained enthusiasm in open source projects, promoting a collaborative and inclusive environment where everyone’s efforts are valued. Vaunt is key in tracking and celebrating various contributions, making it easier to spotlight all contributors and maintain healthy project ecosystems. By fostering a culture of recognition, open source communities can thrive and grow more inclusively.

Why Hacktoberfest Is Important for Beginners

Hacktoberfest is not just a coding event—it’s a celebration of collaboration, community, and learning. By participating, you’ll

• Get hands-on experience with real-world projects

• Learn how to work with others in a collaborative environment

• Gain exposure to tools like Git and GitHub

• Build your coding portfolio and resume

• Earn swag and recognition for your contributions!

Step 1: Get Set Up With Git and GitHub

Before contributing, you’ll need to familiarize yourself with Git (version control tool) and GitHub (platform for hosting code). These are essential for successful participation in Hacktoberfest.

• Install Git: Follow a simple guide to install Git on your computer, whether you’re using Windows, macOS, or Linux.

• Create a GitHub Account: Head over to GitHub and create an account if you don’t have one yet. You’ll need it to contribute to projects.

• A Step-by-Step GitHub guide: Mastering GitHub is a crucial step in your journey. This guide offers key, must-know tips and tricks to help you navigate GitHub confidently and efficiently.

Step 2: Explore Open-Source Projects and Beginner-Friendly Issues

Once you’re set up, it’s time to find projects that you can contribute to. GitHub has millions of repositories, many of which are eager for new contributors—especially during Hacktoberfest.

• Search for Beginner-Friendly Issues: Use labels like good-first-issue or help-wanted to find issues that are beginner-friendly. These are usually simple ones that project maintainers have tagged to help new contributors get started. You can also discover Hacktoberfest projects here.

• Join the Hacktoberfest Site: Officially register for Hacktoberfest via their website so your contributions can be counted toward your goal of four pull requests.

Step 3: Learn the Basics of Pull Requests

A pull request (PR) is how you propose changes to a project. This is the main contribution mechanism for Hacktoberfest. When you find an issue you would like to work on:

1. Fork the Repository: This means creating your copy of the project.

2. Make Changes: Fix bugs, improve documentation, or add new features.

3. Submit a Pull Request: After making your changes, submit a PR so project maintainers can review and merge your changes into the main codebase.

If you’re not sure how to do these, many beginner-friendly tutorials are available, such as this guide to making your first pull request.

Step 4: Contribute to Documentation and Non-Code Projects

Not all contributions need to be about writing code. Hacktoberfest values all types of contributions, including improving documentation, fixing typos, or enhancing project instructions. For beginners, this can be a great way to get comfortable with the open-source process before diving into coding tasks.

Look for projects with documentation-related issues or guides that need updating. This way, you can start contributing without the need for advanced technical knowledge.

Step 5: Collaborate and Learn From the Community

One of the best parts of Hacktoberfest is the chance to connect with the global developer community. Don’t hesitate to ask questions or seek guidance from project maintainers and other contributors. Open-source communities are usually welcoming and happy to help beginners.

• Join Discussions: Participate in project discussions and comment threads to better understand issues.

• Ask for Feedback: After submitting a pull request, project maintainers might ask for changes. View this as a learning opportunity.

Step 6: Stay Consistent and Focus on Learning

Hacktoberfest isn’t just about completing tasks quickly; it’s about growing as a developer. You’ll need to make four pull requests to complete Hacktoberfest—but focus on making meaningful contributions, even if they’re small. Each PR is a chance to learn something new.

Celebrate your progress, no matter how substantial, and stay engaged throughout the month. By the end of Hacktoberfest, you’ll have built new skills, expanded your network, and contributed to projects that help the wider open-source community.

Step 7: Celebrate Your Achievements

At the conclusion of Hacktoberfest, participants who successfully submit four pull requests will unlock a digital badge. But beyond the swag, the real reward is the experience and connections you will have made.

Join Hacktoberfest 2024 to kickstart your open-source journey. Contribute, learn, and be part of something amazing this October!

Get Started Your Hacktoberfest 2024 with Vaunt

Discover Hacktoberfest Projects with Ease and leverage Vaunt's advanced search engine to help you find the perfect projects that align with your interests and skills.

Sign up for Vaunt today and shine a spotlight on your developer contributions!

To stay in the loop on future developments, follow us on X or join our Discord! And don’t hesitate to make feature requests.

What Is Vaunt Open Source Community?

Vaunt Open Source Community is designed to transform the way you find and evaluate open-source projects on GitHub. Whether you’re a developer looking for your next contribution or an organization seeking active maintainers, Vaunt Open Source Community brings precision and clarity to your search.

🚀 We’re Live on Product Hunt! 🚀

If you’re passionate about open source, we’d love your support! Upvote us on Product Hunt and help take Vaunt Open Source Community to more people!

Key Features of Vaunt Open Source Community:

1. Discover the Trending Repos

Vaunt Open Source Community provides real-time insights on trending projects. Now you can easily spot the most active and relevant projects in the community.

2. Power Up Your Search With Advanced Filters

Tired of wading through endless GitHub search results? With advanced filters, Vaunt Open Source Community lets you refine your search to find exactly what you’re looking for. Whether based on language, licenses, or activity level, finding the perfect project has never been easier.

3. Evaluate Open-Source Health

One of the biggest challenges in open source is determining the health and sustainability of a project. Vaunt Open Source Community offers deep insights into community health metrics, helping you gauge the activity, maintenance, and overall vitality of a project before you dive in.

4. Increase Your Project’s Visibility

Are you an open-source maintainer? Vaunt Open Source Community doesn’t just help you find projects—it also helps talented contributors find you. By ensuring that your project is visible to those searching for active, impactful repositories, you can attract the right developers to help your project thrive.

Support Us on Product Hunt

We’re excited to launch Vaunt Open Source Community on Product Hunt, and we’d love your support! If you’re as passionate as we are about improving the open-source ecosystem, please take a moment to upvote us on Product Hunt. Your support will help us reach more developers and organizations, enabling smarter, more impactful contributions across the open-source community.

🚀 Upvote Us on Product Hunt 🚀

Get Started with Vaunt Open Source Community Today

Ready to enhance your GitHub experience? Start searching smarter and engage with thriving communities! 🚀

Sign up for Vaunt today and shine a spotlight on your developer contributions!

To stay in the loop on future developments, follow us on X or join our Discord! And don’t hesitate to make feature requests.

Before we built tqla, we mainly used Squirrel for our SQL query building logic—and we highly recommend it. We still use Squirrel in some areas but have gradually started replacing and implementing new query building logic with tqla. We have found many instances where tqla has improved our ability to maintain our code and fix problems we ran into when using other statement builders.

Real World Use Case

At Vaunt, we recently underwent a database migration from CockroachDB to TiDB. While CockroachDB was performant and reliable, we ultimately faced the decision of adding to our techstack to support an OLAP database. The need for this was to support our analytical workload on our open source community insight product. To keep our technology footprint small, we decided to move forward with TiDB and take advantage of the database’s HTAP architecture.

CockroachDB is largely compatible with PostgreSQL, and we used the PostgreSQL syntax for many of our SQL queries. To switch to TiDB, we had to change a few of our tables and update queries to use MySQL syntax. In a few locations during the migration, we found that we were improperly using conditional query building statements and lacked the proper tests to catch that the statements were being generated incorrectly.

Demonstration

In Squirrel’s README, there is an example of how you can use conditional query building to update statements with optional filters:

if len(q) > 0 {
    users = users.Where("name LIKE ?", fmt.Sprint("%", q, "%"))
}

Here is a real, but simplified, example of how we updated one of our queries to conditionally join tables and add an optional filter:

psql := squirrel.StatementBuilder.PlaceholderFormat(squirrel.Question)

statementBuilder := psql.Select(`i.id`).
From("vaunt.installations i").
Where(`entity_name = ?`, name)

if len(provider) > 0 {
    statementBuilder.Where(`provider = ?`, provider)
}

if len(repo) > 0 {
    statementBuilder.Join(`repositories as r on JSON_CONTAINS(i.repositories, CONCAT('["', r.id, '"]'))`)
    statementBuilder.Where(`r.name = ?`, repo)
}

Can you spot the issue with the code? If not, don’t worry—it is something that slipped through our own code reviews as well until we ran our tests.

The issue here is that we forgot to update the statement builder with the result of the builder functions. For example, the provider condition filter should instead read:

if len(provider) > 0 {
    statementBuilder = statementBuilder.Where(`provider = ?`, provider)
}

This is a relatively simple mistake to make and can easily be caught with sufficient test cases, but because it’s not technically invalid code, it can take a bit to realize what is happening immediately.

Another readability issue with this setup is that the conditional join is separated from the initial select statement. We could reorganize the builder to put each piece where it should go, but it would require multiple duplicate conditional statement checks and still suffer from some readability issues.

Using tqla

The above demonstration using Squirrel has since been rewritten, and the equivalent in tqla looks like this:

t, err := tqla.New(tqla.WithPlaceHolder(tqla.Question))
if err != nil {
    return nil, err
}

query, args, err := t.Compile(`
    SELECT i.id
    FROM vaunt.installations as i
    {{ if .Repo }}
    JOIN vaunt.repositories as r on JSON_CONTAINS(i.repositories, CONCAT('["', r.id, '"]'), '$')
    {{ end }}
    WHERE entity_name = {{ .Name}}
    {{ if .Provider }}
    AND i.provider = {{ .Provider }}
    {{ end }}
    {{ if .Repo }}
    AND r.name = {{ .Repo }}
    {{ end }}
    `, data)
if err != nil {
    return nil, err
}

As you can see, the template syntax for tqla makes incorporating conditional clauses very simple. Tqla automatically replaces the variables we are setting with our specified placeholders and provides the arguments we can use with our sql driver to execute the statement.

Similar to Squirrel, this statement building approach is easy to test, as we can create different sets of data objects to pass to the template builder and validate the output.

You can see that we are easily able to add conditional pieces of the query where they would fit in best. For example, here we have a conditional JOIN directly after the FROM statement—and although we still have multiple condition checks, it does not overly complicate the template.

Custom Functions

Another nice tqla feature helping to improve the maintainability of our sql builders is the ability to define custom functions we could use in the templates to abstract some transformation logic.

Here is an example of how we used a function to convert the Golang’s time.Time value into a sql.NullTime to allow us to do an insert with our data objects without needing to convert it beforehand:

funcs := template.FuncMap{
    "time": func(t time.Time) sql.NullTime {
        if t.IsZero() {
            return sql.NullTime{Valid: false}
        }
        return sql.NullTime{Time: t, Valid: true}
    },
}

t, err := tqla.New(tqla.WithPlaceHolder(tqla.Question), tqla.WithFuncMap(funcs))
if err != nil {
    return err
}

With this function defined in our tqla funcs map, we can now freely use it in our query templates by providing it a parameter from the data object that is a time.Time field. We can even call this function multiple times in the same template with different fields.

Here is a simplified example:

statement, args, err := t.Compile(`
    INSERT INTO events
        (name, created_at, merged_at, closed_at)
    VALUES ( 
        {{ .Name }},
        {{ time .CreatedAt }},
        {{ time .MergedAt }},
        {{ time .ClosedAt }}
    )`, eventData)

Conclusion

In conclusion, we believe that using tqla can help improve the maintainability of query building logic while offering some powerful utility for creating dynamic queries. The simplicity of the template structure allows for clean code readability and can make it faster to debug any potential errors.

We made tqla open source to share this library in hopes that it provides a good option for other users wanting a simple, maintainable, and secure way to build sql queries in many different types of applications.

If you are interested, please check out the repository and give it a star if it helps you in any way. Feel free to make any feature requests or bug reports!

We are always open to receiving feedback and contributions.

To stay in the loop on future development, follow us on X or join our Discord!

1. Learn Basic Git Commands

git init: Initialize a new Git repository

git clone URL: Clone an existing repository from a URL

git add . : Stage all changes for commit

git commit -m “Message”: Commit changes with a message

git push: Push changes to the remote repository

git pull: Fetch and merge changes from the remote repository

2. Understand Branching and Merging

Branching allows you to work on different features or bug fixes independently.

Merging integrates changes from different branches. Use git merge to combine the branches.

git branch new-feature: Create a new branch named “new-feature”

git checkout new-feature: Switch to the “new-feature” branch

git merge new-feature: Merge the “new-feature” branch into the current branch

3. Utilize GitHub Issues and Pull Requests

GitHub Issues are great for tracking bugs, enhancements, and tasks. Create issues to discuss and plan your work.

Pull Requests (PRs) are essential for code reviews and collaboration. Open PRs to propose changes and get feedback before merging them into the main branch.

Example Actions

• Create an issue: Navigate to the “Issues” tab in your repository and click “New Issue”

• Open a pull request: After pushing a branch, navigate to the “Pull Requests” tab and click “New Pull Request”

4. Write Clear Commit Messages

Clear and concise commit messages are essential for any developer using Git. They not only explain the purpose of your changes (e.g., “Fix bug in login module”) but also serve as a historical record for future reference. A good commit message should be informative and easy to understand for anyone reading the codebase. You can learn more here: https://www.conventionalcommits.org/en/v1.0.0/.

5. Leverage GitHub Pages for Documentation

GitHub Pages is a free service to host your project’s documentation or a personal site directly from a GitHub repository. To set it up, create a repository named username.github.io, or enable Pages from the repository settings and choose a branch to serve the site. Learn more here.

Writing a Stunning GitHub Profile README

Creating an attractive and informative GitHub profile README is the first step toward making a lasting impression. It’s your digital business card, a snapshot of who you are as a developer. Here are some tips and tricks to help you design a GitHub profile README that stands out.

1. Set Up GitHub README

To set up a GitHub profile README, simply create a new repository with the same name as your GitHub username. For instance, if your GitHub username is “YourName,” make a repository named “YourName.” Then, create a README.md file in that repository. Whatever you put in this README.md file appears on your GitHub profile. Watch how to do it here.

2. Personal Introduction

Start with a brief personal introduction. Tell the visitors who you are, what you do, and what you are passionate about. This section should be engaging and offer a glimpse of your personality.

3. Include Social Media Profiles

If you’re comfortable sharing, include links to your LinkedIn, Twitter, or personal blog. This enables others to connect with you on multiple platforms and understand more about your professional persona.

4. Embed Vaunt’s SVG Cards

Vaunt, a tool designed for developers, provides embeddable SVG cards that display your GitHub contribution stats. These cards add a visual element to your profile, making it more engaging and professional.

You can simply add the following lines and replace {{github_username}} with your username to your README.

<p>
   <a href="https://vaunt.dev">
       <img src="https://api.vaunt.dev/v1/github/entities/{{github_username}}/contributions?format=svg" width="350" title="Includes public contributions"/>
   </a>
</p>

5. Showcase Your Skills

Your GitHub profile is the perfect place to highlight your technical skills. List down the programming languages, tools, and technologies you are proficient in. Consider using a service like Devicon to add visually appealing icons representing your skills to your profile. This can help potential employers or collaborators quickly understand your areas of expertise.

6. Highlight Your Projects

Your projects are the best representation of your skills. Include a section where you showcase your most impressive or relevant projects. Utilize GitHub’s pinning feature to prioritize your most impactful projects. Learn more here.

7. Add a Personal Touch

Remember to add a personal touch to your profile. Share your interests, hobbies, or fun facts about yourself. This helps to humanize your profile and invites visitors to connect with you on a personal level.

8. Share Examples

Here are some examples of stunning GitHub profile READMEs for inspiration: https://zzetao.github.io/awesome-github-profile/

9. Proofread

Lastly, proofread your README. Ensure that it’s free from typos and grammatical errors. A well-written README reflects your attention to detail and commitment to quality.

Keep It Updated

Remember, your GitHub profile README should be a living document. Keep it updated with your latest projects, achievements, and skills.

Creating an attractive GitHub profile README requires creativity, clarity, and a bit of personality. Remember, it’s not just about listing your skills or projects; it’s also about telling your story as a developer. So start creating a stunning GitHub profile README today, and make a lasting impression on everyone who visits your profile.

Leverage Vaunt to Enhance Your Open-Source Projects

1. Recognize Developer Achievements

Vaunt highlights individual accomplishments, from code commits to issue resolutions, providing a sense of recognition and achievement.

How to Use Vaunt for Recognition

• Badges and Awards: Assign badges for milestones such as first commit, bug fixes, or documentation improvements

• Leaderboard: Maintain a leaderboard showcasing top contributors, fostering a healthy competitive spirit

2. Drive User Contributions

Sustaining an open-source project requires regular and meaningful contributions. Vaunt helps streamline this process by making it easier for users to see where their efforts are most needed.

How to Drive Contributions

• Contribution Guidelines: Use Vaunt to highlight clear contribution guidelines, making it easy for newcomers to get started

• Task Prioritization: Identify and display high-priority tasks or issues that need immediate attention

3. Enhance Community Engagement

Active community engagement is the backbone of successful open-source projects. Vaunt offers tools to keep the community engaged and involved.

Engagement Strategies With Vaunt

• Community Events: Organize and promote events like hackathons or coding sprints directly through Vaunt

• Discussion Forums: Foster active discussions by integrating forums where contributors can share ideas and collaborate

Learn more about how to start with Vaunt here.

To stay in the loop on future developments, follow us on X or join our Discord! And don’t hesitate to make feature requests.

Enter Vaunt, the beacon for tech writers in the open-source sea. Vaunt breathes life into static contributing.md files, transforming them into dynamic, interactive, and trackable components of open-source projects. With Vaunt, tech writers have a robust solution at their fingertips to codify their contribution guidelines and gain valuable insights into developer behavior through gamification elements. Let’s delve into how Vaunt revolutionizes the way we think about contribution guidelines.

1. Codify Contributing Guidelines

Vaunt enables you to transform your contributing.md file into a structured, interactive format. Instead of static text, you can:

• Create clear steps: Break down contribution processes into clear, actionable steps that developers can easily follow.

• Define contribution types: Differentiate various types of contributions, such as bug fixes, feature enhancements, and documentation improvements.

• Set expectations: Clearly outline the expectations for code quality, formatting, and testing procedures.

This codified format makes your contributing guidelines more user-friendly and ensures that developers have a clear understanding of what’s required.

2. Track Contribution Activity

Vaunt goes beyond simply presenting the guidelines. It actively tracks how developers interact with them, incorporating gamification elements to enhance engagement so you can:

• Identify common issues: Analyze developer activity to see which parts of the contributing guidelines are frequently overlooked or misunderstood.

• Monitor contribution types: Gain insights into the types of contributions developers are making, allowing you to identify areas that need more focus or support.

By analyzing this data, tech writers can:

• Refine contributing guidelines: Identify areas for improvement and update the guidelines to address common issues or confusion.

• Provide targeted support: Focus their efforts on areas where developers need more guidance or clarification.

• Demonstrate the impact of their work: Showcase the value of clear contributing guidelines in ensuring project quality and efficiency.

3. Foster a Collaborative Community with Gamification

Vaunt fosters a collaborative environment by:

• Encouraging open communication: Developers can easily ask questions and clarify doubts directly within the codified guidelines, promoting open communication with maintainers.

• Providing recognition: Vaunt allows you to create custom badges to recognize developers for their diligence in following the Contributing.md file.

• Gamification elements: Vaunt incorporates additional gamification elements, such as leaderboards, points systems, and community boards, to further incentivize participation and make contributing a more engaging experience.

Real-World Example: Codifying Our Own Contributing.md File

Here’s an example of how we codified our contributing.md file using Vaunt:

Creating Achievement

First, we utilized Contributing.md generator to start our documentation—but we didn’t stop there. Next, we customized the documentation, codifying our contributing.md file by adding these three achievements:

Star the Repo 🌟

Earn the Mas Tqla badge by starring Tqla. It’s a simple yet powerful way to support our project.

Report a Bug 🐛

Spot a bug? Add a bug label to your issue report. Once confirmed, you’ll be awarded the Bug Hunter badge as a thank you for keeping Tqla robust.

Suggest an Enhancement ⚡

Have a feature in mind? Label your enhancement suggestion with enhancement. If we implement it, you’ll receive the Innovator badge for your visionary input.

Automatic Badge Awards

Secondly, we configure Vaunt achievements to track your impact and award developers’ contributions. Our system automatically awards developers who reach those achievements.

version: 0.0.1 
achievements:
  - achievement:
      name: Mas Tqla!
      icon: https://raw.githubusercontent.com/VauntDev/tqla/main/.vaunt/mas_tqla.png
      description: uno mas, dba..., one more, mas tqla!   
      triggers:
        - trigger:
            actor: author
            action: star
            condition: starred = true
    - achievement: 
      name: Tqla Honey Bee
      icon: https://raw.githubusercontent.com/VauntDev/tqla/main/.vaunt/tqla_honey_bee.png
      description: We bee-lieve in you! This achievement celebrates your first bug report, helping make Tqla sweeter than ever.
      triggers:
        - trigger:
            actor: author
            action: issue
            condition: labels in ['bug'] & reactors in ['elewis787', 'jeff10110322', 'simonmazzaroth']
    - achievement: 
      name: Mojito Tqla
      icon: https://raw.githubusercontent.com/VauntDev/tqla/main/.vaunt/mojito_tqla.png
      description: Your enhancement's a delight! Thanks for making Tqla even brighter than night.
      triggers:
        - trigger:
            actor: author
            action: issue
            condition: labels in ['enhancement'] & reactors in ['elewis787', 'jeff10110322', 'simonmazzaroth']

The above example can be found in our TQLA repository. You can also learn more about how to set up your own achievements.

Community Boards

Third, we utilize Vaunt Community Boards to provide community statistics, repository insights, and a view into repository achievements.

Vaunt Community Boards provide a powerful platform for:

• Tracking project growth: Monitor key metrics like commits, issues closed, and stars to gauge the overall health and popularity of your open-source project.

• Identifying community trends: Gain insights into developer behavior and contribution patterns to understand how your community is evolving.

• Showcasing individual contributions: Recognize and celebrate the contributions of individual developers and teams through achievements and leaderboards.

https://community.vaunt.dev/board/VauntDev/repository/tqla

In a nutshell, Vaunt is revolutionizing the way tech writers support and interact with open-source communities. By turning static guidelines into dynamic tools for collaboration, encouraging engagement through gamification, and providing a platform for recognition, Vaunt ensures that the expertise of tech writers doesn’t just inform—it also inspires and transforms. Dive into the future of open-source contribution with Vaunt, where every guideline is a gateway to greater impact and every contribution is an opportunity for celebration.

Sign up for Vaunt today and shine a spotlight on your developer contributions!

To stay in the loop on future developments, follow us on X or join our Discord! And don’t hesitate to make feature requests.

Why Hacktoberfest Matters

Hacktoberfest is more than just coding; it’s the epitome of community, collaboration, and mutual growth—hallmarks of open-source community management. This is a time when experienced and novice contributors unite to enhance each other’s work, learn, and progress together. Hacktoberfest provides organizations with a unique opportunity to network with international developers and promote contributions to the open-source cause.

Getting Your Organization Ready

1. Set clear contribution guidelines: Spruce up your project’s documentation with crystal-clear contribution guidelines—a fundamental Hacktoberfest best practice. This empowers new contributors with the knowledge needed to begin their journey, submit changes, and understand what types of contributions are welcomed.

2. Tag issues with “Hacktoberfest”: Mark actionable issues with a Hacktoberfest label, steering participants toward well-defined, green-lit tasks and aligning with open-source community engagement strategies.

3. Prepare beginner-friendly issues: Curate a list of beginner-friendly tasks, earmarked with tags like “good-first-issue” or “Hacktoberfest-beginner,” to help those unfamiliar with the open-source realm find suitable challenges. Crafting engaging, rewarding, and comprehensible introductory issues is crucial to maintaining an inclusive and vibrant open-source environment.

4. Prepare mentors: Deploy a cadre of skilled contributors ready to mentor and ensure newbies get the guidance and encouragement they need— fostering a nurturing and mentoring atmosphere.

5. Plan events and workshops: Initiate kickoff events, workshops, or webinars as engaging touchpoints for interaction and collaboration—bolstering open-source community management and participation.

6. Promote your participation: Spread the news about your Hacktoberfest activities across diverse mediums—social media, newsletters, blogs, and tech community forums. Publish teaser posts, regular updates, past triumphs, and future expectations, heightening anticipation and involvement by using tags like #Hacktoberfest2024.

Introducing Vaunt—Your Hacktoberfest Ally

As we share insights on how to prepare for Hacktoberfest, let’s take a moment to introduce Vaunt, your best Hacktoberfest ally. Vaunt is a top developer-endorsed platform. During Hacktoberfest 2023, we tripled partner engagement and built a vibrant collaborative community 🚀.

1. Recognize contributions with digital achievements: Work with Vaunt to create your own custom digital badges to recognize developer contributions—symbolic recognition that boosts motivation and integrates gamification into the open-source experience.

2. Utilize engagement analytics: Leverage Vaunt’s sophisticated tools to track and audit community engagement, revealing the most engaged contributors and dynamics within your community—an exercise in strategic open-source community management.

3. Leverage seamless integration: Rely on Vaunt’s streamlined integration for hassle-free operations alongside your existing systems, ensuring that contributors seamlessly gain the recognition they’ve earned.

4. Capture the community spirit with Vaunt: Easily share success stories, highlight outstanding contributions, and celebrate community efforts with Vaunt—the embodiment of a vibrant and appreciated community culture.

Impact and Looking Forward

As Hacktoberfest unfolds, watch your community engagement soar with the support of Vaunt. Witness the increased motivation, stronger connections, and inclusive environment where every contribution is acknowledged. Take a look at our case study and get ready to take your first step into a more meaningful Hacktoberfest.

Let Vaunt help your organization navigate through the open-source festivities with ease. Recognize, engage, and inspire your developers in new and exciting ways. Visit our website to discover more about how Vaunt can revolutionize your developer relations.

Do you dream of building a thriving open-source community that fuels innovation and fosters collaboration? Stop struggling with fragmented contributions, unwelcoming environments, and unacknowledged efforts. Building a thriving open-source community is just an exciting journey away, paved with the right strategies, empathy, and tools.

In this comprehensive guide, we’ll explore the essential ingredients for cultivating a vibrant community of contributors, fostering innovation, and celebrating shared success. From creating a welcoming atmosphere to establishing clear contribution pathways, we’ll delve into actionable tips and best practices sure to empower your project.

Building a Thriving Open-Source Community: The Power of a Welcoming Environment 🚀

🌟 In the vibrant world of open source, the strength of a community is pivotal to a project’s success. Here are two fundamental steps to create a welcoming and inclusive environment:

1. Encourage Participation ✅: Accessibility is key. Clear guidelines = smooth start. Make it effortless for newcomers to join by offering clear guidelines and a supportive atmosphere. Embrace diversity in your community—it’s the melting pot of innovation and creativity!

2. Foster a Positive Culture 🌈: Establish a code of conduct that champions respect and inclusivity. Small contributions or large, every effort deserves recognition 🎉. Celebrating each milestone builds a sense of belonging and motivates ongoing participation.

💻 A welcoming community isn’t just about growing numbers; it’s also about nurturing an ecosystem where everyone feels valued and empowered to contribute. Let’s make our open-source communities into places where collaboration, respect, and innovation thrive! 🌟

Key to Open-Source Success: Establishing Clear Contribution Paths 🛣️

In the dynamic world of open source, providing clear and accessible paths for contributors is crucial for sustained community engagement and project growth. Here are two fundamental ways to enhance the contributor experience:

1. Well-Documented Issues 📋: The first step in orienting new contributors is ensuring that issues are clearly labeled and documented. This not only helps newcomers navigate through your project with ease but also encourages their active participation. A well-organized issue tracker is a sign of a project’s health and contributor-friendliness.

2. Mentorship Programs 🤝: Beyond documentation, personal guidance is invaluable. Establishing mentorship programs or offering one-on-one support to new contributors can significantly enhance their experience. It helps them integrate into the community, understand the project’s nuances, and contribute more effectively. Beyond building skills, mentorship fosters lasting relationships within the community.

By focusing on these aspects, we can create open-source environments that are productive, welcoming, and nurturing.

Let’s continue to support and guide the bright minds contributing to the open-source world!

Elevating Open-Source Communities: The Art of Recognizing and Rewarding Contributions 🏅

In the collaborative world of open source 🤝, recognizing and rewarding contributions is not just a courtesy; it’s a crucial catalyst for community growth and innovation. Here are two key, effective strategies to acknowledge the efforts of your community members:

1. Regular Acknowledgment 👏: Make it a practice to highlight contributions in your community channels regularly. Whether it’s a simple shout-out or feature in your newsletter, acknowledging contributions publicly not only shows appreciation but also motivates others. It’s about creating a culture where every contribution is seen and valued.

2. Implementing Rewards and Incentives 🏆: Go a step further by setting up a system of rewards and incentives for significant contributions. This could be anything from digital badges, exclusive access to new features, or even spotlighting contributors in prominent community events. Such incentives celebrate achievements while also driving engagement and inspiring ongoing participation.

By integrating these practices, we foster a vibrant open-source ecosystem 💡 where contributions are not just made but celebrated. Let’s continue to nurture environments where every effort is recognized—and every achievement is a shared victory!

Strengthening Open-Source Communities: The Power of Events and Learning 🌐

A thriving open-source community isn’t just about code; it’s about connection and growth. Here are two impactful ways to energize and empower your community:

1. Hackathons and Meetups 🔨: These events are more than just coding marathons; they’re melting pots of collaboration and innovation. Whether it’s a local meetup or an online hackathon, bringing community members together to share ideas and solve problems can spark creativity and forge lasting bonds.

2. Webinars and Workshops 📚: Knowledge sharing is a cornerstone of open source. Hosting educational sessions, whether technical workshops or webinars on best practices, not only helps community members develop new skills but also deepens their connection with the project. It’s a way to nurture both individual talents and the collective strength of your community.

Let’s continue to build open-source communities that are not only technically robust but also rich in opportunities for learning, collaboration, and personal growth. 🎉

Maximizing Impact in Open Source With Social Media and Content 📣

In the digital age, social media and content creation are powerful tools for growing and nurturing open-source communities. Here’s how they can be effectively utilized:

1. Social Media Engagement 🌍: Platforms such as Twitter, LinkedIn, and Reddit aren’t just for updates; they’re stages for celebrating your community’s achievements and engaging with a broader audience. Regular posts about progress, key milestones, and community stories can amplify your project’s visibility and attract new contributors.

2. Blogs and Articles ✍️: Beyond social media, creating detailed blogs and articles offers a deeper dive into your project. This content can highlight the hard work and innovative solutions of your community, share valuable insights about your project’s developments, and acknowledge the contributions of key members. It’s not just about sharing information; it’s about telling the story of your community—its challenges, successes, and lessons learned.

By leveraging these platforms, we can create a narrative that both informs and inspires. Engaging content and an active social media presence can transform your open-source project from a repository of code into a vibrant, collaborative community.

Let’s harness the power of digital storytelling to celebrate our open-source journey and connect with fellow enthusiasts across the globe!

Conclusion

The journey of building a thriving open-source community is an ongoing adventure, filled with unique challenges and rewarding triumphs. By prioritizing a welcoming environment, well-defined contribution paths, genuine recognition, engaging events, and open communication, you can create a collaborative hub where innovation thrives. And along this journey, remember that you’re not alone.

Vaunt stands as a dedicated partner, offering a toolbox specifically designed to nurture your community’s growth. Whether it’s boosting project visibility, streamlining contributions, or recognizing the invaluable efforts of your members, Vaunt empowers you to cultivate a vibrant ecosystem where collaboration and connection flourish.

Embrace these strategies and tools like Vaunt to transform your open-source project from a repository of code into a vibrant tapestry of engaged minds, pushing the boundaries of possibility together.

Sign up for Vaunt today and shine a spotlight on your developer contributions!

To stay in the loop on future developments, follow us on Twitter or join our Discord! And don’t hesitate to make feature requests.

The Spark of an Idea: Recognition Reimagined

Vaunt was born from a simple question: How do we enable developers and organizations to celebrate and share achievements in a more meaningful and personal way? We’ve seen our thriving developer community create great things, from unique laptop stickers commemorating hackathon wins to customized T-shirts for breakthroughs on major projects. However, there was no unified platform to promote this kind of celebration of professional growth and creativity.

Enter Vaunt: A Community Spotlight

Vaunt is far more than just a software platform; it’s a dedicated space where developer achievements take center stage. It answers the call for a platform where individual contributions, no matter how seemingly small, are recognized and celebrated. With Vaunt, we’re not just building software; we’re crafting a home for the stories that shape our journeys as developers.

From Personalized Recognition to Global Celebration

Vaunt offers a suite of features designed to transform how developers share their successes with the world. This includes:

• Custom achievements: Organizations can create unique achievements to recognize specific skills or project milestones.

• Meaningful badges: Individual developers can earn badges that celebrate their accomplishments and skill mastery.

• Community connections: Vaunt fosters connections among developers, enabling them to share their stories and inspire each other.

From custom achievements for organizations to badges that celebrate individual milestones, Vaunt aims to transform how developers share their successes with the world. It’s about turning every “What’s that sticker?” moment into a story of achievement, learning, and inspiration.

Join the Movement: Celebrate Your Success

Vaunt thrives on the energy of the developer community. Every developer who shares their story, every organization that embraces a culture of recognition, and every discussion that fuels new features contributes to our growth.

We built Vaunt for you, the creators, problem solvers, and innovators who shape the tech landscape. We invite you to join us in celebrating your achievements and those of your fellow developers. Together, let’s make Vaunt a beacon of recognition in the open-source world.

Sign up for Vaunt today and shine a spotlight on your developer contributions!

To stay in the loop with future developments, follow us on X or join our Discord! And don’t hesitate to make feature requests.

Keploy, a cutting-edge API testing platform, faced the challenge of effectively engaging their developer community and showcasing the real-world impact of their contributions. With a mission to simplify API testing through automation and minimize manual effort, Keploy sought innovative ways to acknowledge and motivate their community.

Challenge

Despite Keploy’s innovative approach to automating API testing, they had difficulties engaging their rapidly growing developer community and effectively recognizing individual contributions.

Solution: Collaborative Effort During Hacktoberfest

Keploy and Vaunt collaborated during Hacktoberfest, a month-long celebration of open-source contributions, to spotlight developers who made significant contributions to Keploy’s platform.

Hacktoberfest #1 - Recognize, Celebrate and Connect open source Developers.

• Implementation Process: Keploy devised a strategy to utilize Vaunt’s unique features, integrating them with Keploy’s Hacktoberfest activities to enhance participant recognition and engagement.

• Digital Badges for Contributors: Custom digital badges were created to acknowledge and reward developers for their contributions during Hacktoberfest, making their achievements visible and shareable. https://github.com/keploy/keploy/blob/main/.vaunt/config.yml

• Community Analytics: Keploy leveraged Vaunt’s analytics to monitor engagement levels and identify active contributors, enabling the team to better understand community dynamics and tailor communications. https://community.vaunt.dev/board/keploy/repository/keploy

Impact

6/1/2023–8/31/2023 (Without Vaunt)

9/1/2023–11/30/2023 (With Vaunt)

Source: https://community.vaunt.dev/board/keploy/repository/keploy

• 100% increase in commit quarterly

• 300% increase in issue opens quarterly

• 900% increase in issue comments quarterly

• 100% increase in PR opens quarterly

• 200% increase in PR comments quarterly

• 900% increase in review quarterly

• 100% increase in stars quarterly

“This collaboration not only improved Keploy’s ability to connect with a broader audience but also offered deep insights into the effectiveness of their engagement strategies, setting a new standard in celebrating and motivating open-source contributors.” Animesh Pathak, founding DevRel engineer

Conclusion

Keploy’s collaboration with Vaunt transformed their approach to community engagement, turning recognition into a powerful tool for motivation and connection. As Keploy continues to grow, the insights gained from this partnership will guide community strategies, ensuring Keploy’s developer ecosystem remains vibrant and engaged.

For more information about how Vaunt can transform your community engagement, visit our website or contact us directly.

Think of GSoC as Hacktoberfest on Steroids

• Deeper Impact: Instead of quick pull requests, you work on a 3-month project, making a significant contribution to a real-world open-source project used by thousands.

• Expert Mentorship: Get personalized guidance and support from experienced developers, honing your skills and gaining invaluable insights.

• Network Building: Connect with a global community of developers, mentors, and organizations, expanding your professional network.

• Resume Booster: Showcase your open-source experience and stand out to potential employers.

GSoC vs. Hacktoberfest: Same Spirit, Different Depth

Both events celebrate open-source contributions, but their intensity and impact differ:

To qualify for Google Summer of Code, contributors must meet several criteria: Contributors must be 18 years or older at the time of registration and either students or new to the open-source community. Additionally, participants must reside in a country not subject to any U.S. embargo.

Review contributor terms

Ready to Dive Into GSoC 2024?

Here are the Key Dates to Be Aware Of:

• March 18, 2024 | Contributor proposals open

• April 2, 2024 | Proposal deadline

• November 14, 2024 | Program ends

View program timeline

Don’t let the application process daunt you. Utilize GSoC’s resources and build relationships with mentors. Remember, the open-source community thrives on collaboration!

Organization

For organizations, participating in GSoC offers different values compared to Hacktoberfest. While Hacktoberfest encourages quantity with its focus on pull requests, GSoC emphasizes quality through more substantial, focused contributions. Organizations involved in GSoC can expect to engage with students or open-source beginners who are committed to working on a project for several months, offering a chance to mentor new talent and integrate significant improvements or new features into their projects. This deeper level of involvement can lead to more meaningful advancements in the project’s development.

Fresh Talent and Contributions

• Access to a pool of talented students and developers: GSoC attracts a large pool of skilled students eager to contribute to open-source projects. This enables you to tap into new talent and perspectives, potentially leading to valuable contributions to your project.

• Improved code quality: GSoC students are mentored by experienced developers, ensuring that their contributions are well-written, documented, and tested. This can lead to an overall improvement in the quality of your codebase.

Community Growth and Engagement

• Expanding your developer community: GSoC can help you attract new developers to your project and community. These developers may continue to contribute after the program is over, leading to a more active and engaged community.

• Increased visibility and outreach: Participating in GSoC can raise awareness of your project and attract attention from a wider audience, including potential users, contributors, and sponsors.

Additional Benefits

• Financial stipend: Google provides a financial stipend to organizations for each accepted GSoC student. This can be used to support the project and compensate mentors.

GSoC 2024 Key Dates

• Apr 30, 2024 | Projects announced to organizations

• May 1, 2024 | Announcement of accepted projects

• Nov 14, 2024 | Program end date

We recognize the similarities and unique advantages both Hacktoberfest and GSoC offer to the open-source community. Vaunt has proven invaluable in managing contributions during Hacktoberfest, showing its potential to significantly benefit organizations participating in GSoC.

Vaunt Benefits for GSoC

• Simplify communication: Stay connected with students and easily track project progress.

• Gain valuable insights: Track code contributions, identify valuable contributors, and measure project impact.

• Spotlight contributions: Highlight developers’ contributions and showcase their contributions to the repository.

With Vaunt, organizations can maximize their GSoC involvement and nurture the next generation of open-source rockstars. Learn more about Vaunt!

Join the adventure! Whether you’re a developer seeking an enriching challenge or an organization ready to empower the future, GSoC offers a unique opportunity. And for organizations, Vaunt acts as your trusty copilot, ensuring a smooth and rewarding GSoC experience. So step beyond pull requests and embark on an unforgettable open-source journey with GSoC and Vaunt!

Sign up for Vaunt today and shine a spotlight on your developer contributions!

To stay in the loop with future developments, follow us on X or join our Discord! And don’t hesitate to make feature requests.

Our partner looked to Vaunt, a platform for open-source communities, to successfully distribute digital badges to participants in their docs improvement hackathon, encouraging contributions to their documentation and fostering a stronger community around the project.

Challenge

Manual badge distribution for a large event can be time-consuming and prone to errors. Our partner needed a solution that could

• Automate badge issuance: Eliminate manual work and ensure accurate badge delivery.

• Personalize badges: Allow custom badge design using their brand guidance.

• Recognize and award participants: Award badges based on specific participation criteria, such as PR, issue, etc.

Solution

Our partner integrated Vaunt with several of their GitHub Doc repositories, allowing seamless achievement awards based on predefined criteria for participation scores. For example, participants who completed specific tasks or contributed content received corresponding scores, and the top five contributors earned special badges.

Benefits

• Increased efficiency: Automated badge distribution saved our partner significant time and resources.

• Improved accuracy: Manual errors were eliminated, ensuring everyone received the correct badge.

• Enhanced engagement: Personalized badges motivated participants and boosted community spirit.

• Valuable data insights: Data provided by Vaunt on badge acquisition and engagement will aid future event planning.

Results

• Badge distribution: Vaunt successfully issued over 70 digital badges to docs improvement hackathon participants.

• Positive feedback: Participants praised the personalized badges and appreciated valuable recognition for their contributions.

Call to Action

Sign up for Vaunt today and shine a spotlight on your developer contributions!

To stay in the loop on future developments, follow us on X or join our Discord! And don’t hesitate to make feature requests.

That’s exactly what we at Vaunt have been pondering. We recognize that organizations play a vital role in shaping the open-source landscape, and we see an opportunity to focus on their collective achievements and milestones. This review is not only a recognition of the work of the past year, but also an affirmation and inspiration for the future.

In the collaborative spirit of open source, we believe that organizations, just like individual contributors, deserve to celebrate their annual journey. That’s why we’re thrilled to introduce Vaunt’s Organization GitHub Wrap, a feature designed specifically for organizations to celebrate their year on GitHub.

Visit https://community.vaunt.dev/github/wrapped/2023 to begin your journey

What Is Vaunt’s Organization GitHub Wrap?

Vaunt’s Organization GitHub Wrap is a year-end summary tailored for organizations managing projects on GitHub. It provides a comprehensive, visually appealing, and data-driven recap of your project’s performance over the year. Covering metrics such as number of repositories created, issues opened and closed, and more, this feature is custom-built to reflect the unique dynamics and accomplishments of your open-source initiatives.

Key Features and Benefits

Highlight Community Achievements: Celebrate your project’s significant breakthroughs, showcasing the journey and progress made over the year.

Engage Your Community: Share your GitHub Wrap with your community and stakeholders, not just as a report, but also as a story of collective success, enhancing engagement and solidarity.

Get Started With Your Organization GitHub Wrap

Embrace the year-end celebration with Vaunt’s Organization GitHub Wrap. Visit https://community.vaunt.dev/github/wrapped/2023 to begin your journey. It’s time to turn data into stories and numbers into narratives—and wrap up the year on a high note.

How It Works

Generating your organization’s GitHub Wrap with Vaunt is a seamless process. Simply enter a GitHub organization name into the website. Vaunt uses the public GitHub API to collect fascinating insights about the repos owned by the organization, and the data is beautifully transformed into a formatted SVG wrap.

This wrap isn’t just a summary—it’s a celebration of your year’s journey in code, designed to be shared and enjoyed. Perfect for social media highlights, community forum discussions, or as part of your internal team showcases.

But Vaunt does more than just recap annual statistics; it’s a gateway to deeper community engagement and insights. By installing Vaunt, you gain access to much more granular details and data about your community. Install Vaunt today and start uncovering the deeper story behind your community's contributions.

Why Choose Vaunt’s Organization GitHub Wrap?

Vaunt’s Organization GitHub Wrap goes beyond statistics; it’s a testament to your community’s dedication, progress, and collaborative spirit. Suited for organizations of all sizes, from emerging startups to established enterprises, the wrap serves as a mirror reflecting your project’s vitality and community health.

Good news—it also supports the same metrics for individual users! You can leverage your wrap and share it on your social media to highlight your personal contributions as well.

Conclusion

As the open-source world continues to evolve and expand, Vaunt’s Organization GitHub Wrap stands as a beacon of celebration and insight. It’s more than a tool; it’s a reflection of your journey and triumphs, and the unyielding spirit of collaboration that drives the open-source community. As 2024 unfolds, we eagerly anticipate the rich, detailed insights that next year's 2024 wrap will reveal. Join us in embracing a more insightful and rewarding way to conclude your year in open source.

Vaunt is a powerful tool that helps you showcase your developer contributions. With Vaunt, you can create meaningful, interactive SVG cards that celebrate your community’s achievements and contributions. You can also use Vaunt’s public API to get data on contributions. And even leverage Vaunt for hero programs or to host hackathons.

Sign up for Vaunt today and shine a spotlight on your developer contributions!

To stay in the loop on future developments, follow us on Twitter or join our Discord! And don’t hesitate to make feature requests.

The month of Hacktoberfesft is coming to a close, and it's time to unveil the remarkable insights we've gathered. At Vaunt, we've been on a mission to support open-source communities, incentivize developers, and recognize their valuable contributions. Let's dive into the data we've collected from this fantastic open-source celebration.

Hacktoberfest and Vaunt

For the uninitiated, Hacktoberfest is an annual event that encourages open-source contributions, organized by DigitalOcean. This year, Vaunt joined in to celebrate the contributions of developers to the open-source community.

Collecting Valuable Data

Vaunt leveraged an archive of GitHub data to gain insights into Hacktoberfest. You can find more information about this archive at GH Archive, including how the archive has been made available through a public BigQuery dataset. Additionally, we've developed our own GitHub app to streamline data collection. The app captures information about pull requests, issues, commits, reviews, stars, and discussions.

The archive dataset in BigQuery can be used to find events directly related to Hacktoberfest by checking for events with the type “PullRequestEvent” and parsing valuable information from the payload. For example, you can check the base repository topics for “hacktoberfest” as well as look for labels including “hacktoberfest” or “hacktoberfest_accepted” and get additional information such as the created_at time of the PR and whether it was closed.

Here is a snippet of one of the queries we used when checking for authors of multiple pull requests in repositories with the Hacktoberfest topic or label:

SELECT JSON_EXTRACT_SCALAR(payload, '$.pull_request.user.login') FROM githubarchive.day.20231001
  WHERE (type="PullRequestEvent" and (JSON_EXTRACT(payload, '$.pull_request.base.repo.topics') like '%"hacktoberfest"%'
  OR JSON_EXTRACT(payload, '$.pull_request.labels') like '%"hacktoberfest"%'
  OR JSON_EXTRACT(payload, '$.pull_request.labels') like '%"hacktoberfest_accepted"%')
  AND JSON_EXTRACT_SCALAR(payload, '$.pull_request.state')='closed'
  AND JSON_EXTRACT_SCALAR(payload, '$.pull_request.created_at') > '2023-01-01T00:00:00Z'
  AND JSON_EXTRACT(payload, '$.pull_request.labels') not like '%"spam"%'
  AND JSON_EXTRACT(payload, '$.pull_request.labels') not like '%"invalid"%')
  GROUP BY 1 HAVING COUNT(distinct repo.name) >= 2 AND COUNT(*) >= 4 limit 10;

The GitHub Impact

GitHub has been at the heart of Hacktoberfest. As of our last check, there were over 139,000 repositories with the Hacktoberfest topic. These repositories have participated in the event over the past ten years and have retained the topic. This demonstrates the long-lasting impact of this open-source celebration.

Active Stats

This year, we've collected data from 42,000 unique repositories that had pull requests, issues, or reviews labeled with Hacktoberfest. The data also includes 63,000 users who've contributed in various ways, and 5,481 unique organizations participating.

User Engagement: The numbers speak volumes. The engagement in GitHub repositories with Hacktoberfest activity was substantial. It reflects the enthusiasm of developers in the open-source community.

A Month of High Activity

The activity in GitHub repositories marked with the Hacktoberfest topic saw spikes during the early days of October. These surges demonstrate how developers eagerly joined the event. The activity dipped slightly over weekends, as expected, but it remained relatively high throughout the month.

A Surge in Open Issues

While Hacktoberfest didn't specifically track issues for awards, maintainers actively opened issues with the Hacktoberfest label to encourage contributions. This led to a surge of opened issues in the early days of the event, and many were subsequently closed, showing a significant level of developer engagement.

A Glimpse of GitHub Archive Data

Our analysis of GitHub archive data for two months, September and October, reveals an impressive story. The number of users who made contributions doubled during October, coinciding with Hacktoberfest. Repositories that received contributions also doubled in number. This data demonstrates the undeniable impact of Hacktoberfest on open-source contributions.

Custom Achievements and More

With the data collected, Vaunt created a set of custom achievements to recognize participating users. Some of these achievements are similar to the Hacktoberfest criteria and a few are custom-made ones to make the event even more special.

Our first achievement, Stellar Starter, was awarded to any user who contributed to a GitHub repository with the Hacktoberfest topic during October 2023. This includes creating, reviewing, or commenting on pull requests or issues. This achievement was meant to be more open to allow as many users as possible who are contributing to Hacktoberfest to qualify. So far 61,180 users have been identified that earned this achievement.

The second achievement is called Cosmic Coder. This is awarded to users who created and merged 2 or more qualifying pull requests to a Hacktoberfest repository during October 2023. This one is meant to be a little more challenging to earn than the starter and is similar to the Hacktoberfest award, however, only requires 2 pull requests instead of 4. So far 31,478 unique users have qualified for this achievement.

The third achievement is called Interstellar Voyager. This one is awarded to users who created and merged 4 pull requests to multiple repositories with the Hacktoberfest topic during October 2023. One additional stipulation of this achievement is that the users must be contributing to more than one repository, which is slightly different from the Hacktoberfest award. So far 11,818 users have qualified for this achievement.

From the GH Archive data that we processed, we found that a majority of users who participate in Hacktoberfest only contribute to a single repository. So we thought it would be nice to reward users who make significant contributions to more than one repository during the event.

Our last achievement is called Galactic Hacker. This one is awarded to users who create and merge 4 pull requests to multiple repositories and close 4 issues that were created during October 2023. These criteria were chosen to be significantly more difficult to achieve to recognize users who go above and beyond to contribute to open-source repositories. So far this achievement has been awarded to 471 users.

Install Vaunt

All of these achievements are specifically granted through Vaunt, which can be installed for free for users from the GitHub Marketplace. If you contributed during Hacktoberfest and would like to show off your achievements on your own personal GitHub README, then just install Vaunt and follow our guide to set up your profile here.

Once you have Vaunt installed you can add the following code to your README.md on your profile to show your Achievement badges by just replacing {github_username} with your username:

<p>
  <img src="https://api.vaunt.dev/v1/github/entities/{github_username}/achievements?format=svg&limit=3" width="350" />
</p>

Contributions from October are still being processed and reviewed so allow some time for the achievements to be added.

Conclusion

The data we've gathered paints a clear picture of the incredible impact of Hacktoberfest. It showcases the unwavering dedication of the open-source community and the power of collaborative development. As Hacktoberfest draws to a close, Vaunt celebrates the countless developers who've dedicated their time and expertise to enriching the world of open source.

With this incredible data in hand, we're excited to continue our mission of supporting open-source communities and rewarding developers for their contributions. Let's make open source even better, together!

Sign up for Vaunt today and start showcasing your developer contributions!

To stay in the loop on future developments follow us on Twitter or join our Discord! Don't hesitate to make feature requests.

In software development, adaptability is key. As code evolves, so does the challenge of simplicity and readability. This issue invariably emerges when developing large-scale applications necessitating numerous diverse SQL statement variations.

Static SQL queries often fall short when you need some form of conditional query generation. Crafting dynamic queries in Golang requires mastery of SQL and the nuances of Golang.

The hurdles include preventing SQL injection, using parameterized queries, managing query complexity, optimizing performance, and maintaining code readability.

In this article, we will dive into strategies and libraries designed to tackle these issues and introduce a new library called tqla ( pronounced tequila ) that leverages Golang’s powerful text/template package to generate dynamic conditional SQL statements securely with ease. If you are new to templating with Golang, I would suggest getting started by reading the docs and this blog from Digital Ocean.

All of the code for this article can be found on GitHub.

Challenges of Building Dynamic SQL Query

Many software applications require conditional SQL statements. This often becomes more apparent when developing an API that allows for some level of filtering or pagination. As queries become more dynamic, challenges arise.

At a glance, a few challenges include:

• Security: It is important to ensure that your dynamic SQL queries are secure and that they do not expose sensitive data.

• Performance: Dynamic SQL queries can be slow, especially if they need to be split into multiple statements due to query builder limitations.

• Maintainability: It can be difficult to maintain dynamic SQL queries, especially as they become more complex due to business logic or conditional formatting constraints.

Let's walk through a real-world example that highlights these challenges.

Todo Application

In a previous article, we announced a generic, lightweight, HTTP handler framework that simplifies request/response marshaling. We built a very basic Todo Application that exposes an API that supports basic operations such as creating and retrieving todos.

In this post, we will focus primarily on our todo service, which is responsible for storing and retrieving todos from a data store. Specifically, we will extend our service to use a database. As we implement each database function, we will walk through how tqla can be used to avoid the challenges mentioned above.

Database Creation

To keep things simple we will be storing todos in Sqlite. Creating the database in Golang can be done with the following code:

db, err := sql.Open("sqlite3", “example.db”)
if err != nil {
    log.Fatal(err)
}
defer db.Close()

The above code creates a db connection to a local called example.db. Once the database has been created and the connection is established, we can set up our todo table.

Below is our todo table schema:

create table if not exists todos (
  id text primary key,
  title text not null,
  description text not null,
  completed boolean default 0,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP 
);

We can apply our schema by leveraging the previously created db connection as follows:

if _, err := db.Exec(todoSchema); err != nil {
    log.Fatal(err)
}

Now that we have a database setup, we will implement our service that will store and retrieve todos.

Service Definition

Our Todo service will have three functions, Add, Get, and List.

type TodoService struct {
    db *sql.DB
}

func (ts *TodoService) Add(todos []pb.Todo) error { return nil}
func (ts TodoService) Get(id string) (pb.Todo, error) { return nil,nil }
func (ts TodoService) List(filter Filter) ([]*pb.Todo, error) { return nil,nil}

Let's start by implementing the Add function. Since we always have more things Todo than we have time for, our Add function accepts multiple Todos.

There are a number of ways we can implement this using our db driver. Since we know there can be more than one to-do, we will want to attempt to add all eligible insert values to our statement.

Below are several implementations that use different techniques to build a database statement and argument slice.

Standard Library SQL Statement

Before tqla, a solution that uses only the standard library might look something like this:

valueStatement := make([]string, 0, len(todos))
args := make([]any, 0)
for _, t := range todos {
    valueStatement = append(valueStatement, "(?, ?, ?, ?, ?)")
    args = append(args, t.Id, t.Title, t.Description, t.Complete, t.CreatedAt)
}
stmt := fmt.Sprintf("INSERT INTO 'todos' ('id', 'title', 'description', 'completed', 'created_at') Values %s",
    strings.Join(valueStatement, ","))

_, err := db.Exec(stmt, args...)

In this example, we continue to append to the original statement and track arguments in order. However, this statement can get even more complex if you are using a database like Postgres, which requires placeholders to be $number instead of ?.

I’ll spare everyone by excluding the function that I’m sure many of us have written that finds and replaces all ? with $number placeholders...

While this example is simple, most people will likely feel the need for a library that can assist with building an SQL statement.

Up next, we will be using a simple statement builder to help offload some of the complexity in the above implementation.

Squirrel Statement Builder

Many awesome SQL statement builders exist. One of our favorites is squirrel. If you haven’t checked it out, please do! Having familiarity with squirrel will help provide context on why we decided to build tqla.

Let’s rewrite the above example using squirrel as the query builder.

psql := squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar)

stmt := psql.Insert("todos").
    Columns("id", "title", "description", "completed", "created_at")

for _, t := range todos {
    stmt = stmt.Values(t.Id, t.Title, t.Description, t.Complete, t.CreatedAt)
}

insertStmt, insertArgs, err := stmt.ToSql()
if err != nil {
    return err
}

_, err := db.Exec(insertStmt, insertArgs...)

The above has several advantages compared to our first implementation. We no longer need to worry about tracking the statements and arguments.

Additionally, squirrel has also removed the need for placeholder formatting, meaning we no longer have to worry about what placeholder syntax our db requires.

That said, one big drawback, is we have lost the ability to see the majority of the query. Squirrel follows a builder pattern, which abstracts some of the common SQL syntax from us. This also means our SQL statement must fit into the builder functions Squirrel exposes.

Any familiar squirrel user knows that this can cause problems with nested selects, and complex joins.

As your applications grow, and you include limits, pagination, or other custom filters the amount of query sprawl grows with squirrel. Eventually, you are left with large functions with a limited understanding of what the final query could be without extensive review.

Tqla Statement Builder

Let's try one last implementation, now using tqla.

t, err := tqla.New(tqla.WithPlaceHolder(tqla.Dollar), tqla.WithFuncMap(exampleFuncs))
if err != nil {
    return err
}

insertStmt, insertArgs, err:= t.Compile(`{{ $length := sub ( len . ) 1 }}
INSERT INTO 'todos' ('id', 'title', 'description', 'completed', 'created_at') 
VALUES {{ range $i, $v := . }}
( {{$v.Id}}, {{$v.Title}}, {{$v.Description}}, {{ $v.Complete }}, {{ $v.CreatedAt }} ){{if lt $i $length}},{{else}};{{end -}}
{{end}}`, todos)

if err != nil {
    return err
}

_, err := db.Exec(insertStmt, insertArgs...)

The above example blends both of our previous solutions and provides more visibility and control into how the statement is built. Tqla still handles many of the messy details of query building, such as tracking arguments, ensuring safety, and driver interoperability. Most importantly, tqla extends Golang’s text templating by leveraging all of the powerful built-in capabilities of templating while preventing SQL injection.

We believe that tqla provides a more flexible and powerful query builder.

Our final Add implementation is as follows

func (ts *TodoService) Add(todos []pb.Todo) error {
    // Init TQLA with the DB placeholder to use and additional functions that can
    // be called by the template.
    t, err := tqla.New(tqla.WithPlaceHolder(tqla.Dollar), tqla.WithFuncMap(exampleFuncs))
    if err != nil {
        return err
    }
    insertStmt, insertArgs, err := t.Compile(`{{ $length := sub ( len . ) 1 }}
        INSERT INTO 'todos' ('id', 'title', 'description', 'completed', 'created_at') 
        VALUES {{ range $i, $v := . }}
             ( {{$v.Id}}, {{$v.Title}}, {{$v.Description}}, {{ $v.Complete }}, {{ $v.CreatedAt }} ){{if lt $i $length}}, {{else}}; {{end -}}
        {{end}}`, todos)
    if err != nil {
        return err
    }

    if _, err := ts.db.Exec(insertStmt, insertArgs...); err != nil {
        return err
    }

    return nil
}

In case you're not convinced to give tqla a try, let's take a look at a few more examples by implementing our remaining functions.

Additional Tqla Examples

Up next, we will implement our Get todo function. The purpose of this example is to show how even simple queries can leverage tqla.

func (ts *TodoService) Get(id string) (*pb.Todo, error) {

    t, err := tqla.New(tqla.WithPlaceHolder(tqla.Dollar))
    if err != nil {
        return nil, err
    }

    selectStmt, selectArgs, err := t.Compile(`
    select id,title, description, completed, created_at 
    from todos 
    where id= {{ . }}`, id)
    if err != nil {
        return nil, err
    }

    todo := &pb.Todo{}
    row := ts.db.QueryRow(selectStmt, selectArgs...)
    if err := row.Scan(&todo.Id, &todo.Title, &todo.Description, &todo.Complete, &todo.CreatedAt); err != nil {
        log.Println(err)
        return nil, err
    }

    return todo, nil
}

In this example, our function takes a todo ID which is supplied to our SQL template using tqla. The ID variable is replaced directly by tqla to create a final select statement that looks like this:

select id, title, description, completed, created_at from todos where id=$1

While tqla may not be needed in every SQL statement use case, our goal is to make it as low friction as possible so that it can grow with your application as query requirements change.

With the the Get function out of the way, all that is left is to implement our List function.

For our List function, we have a few more requirements. We need to support a Limit and optionally pagination by using a Before and After cursor. For pagination, we will use a base64 encoded string that is a combination of the created_at and id columns. We will use Before and After to represent the direction of the cursor for pagination.

func (ts *TodoService) List(filter *Filter) ([]*pb.Todo, error) {

    t, err := tqla.New(tqla.WithPlaceHolder(tqla.Dollar), tqla.WithFuncMap(exampleFuncs))
    if err != nil {
        return nil, err
    }

    selectStmt, selectArgs, err := t.Compile(`
    SELECT id, title, description, completed, created_at 
    FROM todos 
    {{ $page := ( parseCursor .After .Before .Limit ) }}
    {{ if $page.Forward }}
        WHERE (created_at,id) > ({{ $page.CreatedDttm }},{{ $page.Id }})
    {{ else }}
        WHERE (created_at,id) < ({{ $page.CreatedDttm }}, {{ $page.Id }})
    {{ end }}
    ORDER BY created_at
    LIMIT {{ $page.Limit }}
    `, filter)
    if err != nil {
        return nil, err
    }

    rows, err := ts.db.Query(selectStmt, selectArgs...)
    if err != nil {
        return nil, err
    }

    todos := make([]*pb.Todo, 0)
    for rows.Next() {
        todo := &pb.Todo{}
        if err := rows.Scan(&todo.Id, &todo.Title, &todo.Description, &todo.Complete, &todo.CreatedAt); err != nil {
            return nil, err
        }

        todos = append(todos, todo)
    }

    return todos, nil
}

The above example shows the full power of tqla by also leveraging a feature called custom functions.

Custom Functions

The above examples showcase how tqla can be used in a number of use cases. Keep in mind that tqla is simply a query builder with the main focus of ensuring proper variable placeholder replacement.

That said, there are a few tricks that we have not covered yet. A unique and powerful feature of tqla is the ability to implement custom functions. Above, we created a function called parseCursor.

Here is how the parseCursor function is implemented:

// tqla can be expanded through custom functions.
var exampleFuncs = template.FuncMap{
    // parseCursor creates a Pagination object from a base64 encoded cursor.
    // Uses after if before is empty other wise uses before. If both after and before are set
    // then the Pagination object returned in nil.
    "parseCursor": func(after string, before string, limit uint8) *Page {
        cursor := ""
        forward := false
        createdDttm := ""
        id := ""

        if len(after) > 0 && len(before) == 0 {
            forward = true
            cursor = after

        } else if len(before) > 0 && len(after) == 0 {
            forward = false
            cursor = before
        }

        if len(cursor) > 0 {
            data, err := base64.StdEncoding.DecodeString(cursor)
            if err != nil {
                return nil
            }
            values := strings.Split(string(data), "/")
            if len(values) == 2 {
                createdDttm = values[0]
                id = values[1]
            }
        }

        if limit > maxLimit {
            limit = maxLimit
        }

        t, _ := time.Parse("2006-01-02T15:04:05Z", createdDttm)
        return &Page{
            Forward:     forward,
            CreatedDttm: t,
            Id:          id,
            Limit:       limit,
        }
    },
}

These functions can then be registered with tqla through the options pattern.

Here is an example:

t, err := tqla.New(tqla.WithFuncMap(exampleFuncs))
    if err != nil {
        return nil, err
    }

There are a myriad of use cases for custom functions and they are a unique feature that provides the flexibility to extend tqla for your specific use cases.

Tqla at Vaunt

At Vaunt, we have begun replacing squrriel with tqla. So far we have been extremely happy with the flexibility with tqla.

Here is a recent use case

data := struct {
        Provider   string
        ExternalId string
        Member     string
        UpdatedAt  time.Time
    }{
        Provider:   provider,
        ExternalId: externalId,
        Member:     member,
        UpdatedAt:  updatedAt,
    }

    templateFuncs := template.FuncMap{
        "toArray": func(val string) string {
            return "{" + val + "}"
        },
    }

    t, err := tqla.New(tqla.WithPlaceHolder(tqla.Dollar), tqla.WithFuncMap(templateFuncs))
    if err != nil {
        return err
    }

    updateStmt, updateArgs, err := t.Compile(`
    update vaunt.entities 
        set members = array_append(members, {{ .Member }})
    where (members is null OR not members @> {{ toArray .Member }}) and provider = {{ .Provider }} and external_id = {{ .ExternalId }} and updated_at < {{ .UpdatedAt }};
    `, data)
    if err != nil {
        return err
    }

    _, err = crdb.conn.Exec(ctx, updateStmt, updateArgs...)
    if err != nil {
        return err
    }

The goal was to write a query that would append a value to a member array if the value was not already contained in the array. The array contains function '@>' in Postgres is used to compare two arrays, as described here.

The second argument needed to be an array containing the value we wanted to check. Using tqla, we were able to do this by writing a custom template function that turned our string argument into a string array for comparison.

Contribute

We believe strongly in open-source technology and developer-led growth. Vaunt is a tool that focuses on showcasing contributors and highlighting the contributions that they make.

There are a number of ways to contribute to tqla. You can get started by reviewing our Contributing.md doc and checking out any open issues.

To help thank tqla contributors, we have enabled several custom achievements that can be earned, powered by Vaunt. We believe in the tools we are building and of course, leverage them ourselves.

Go check out our tqla's community page to see the latest contributors who have earned achievements on tqla!

The following manifest outlines how achievements can be earned on tqla

version: 0.0.1
achievements:
  - achievement:
      name: Mas Tqla!
      icon: https://raw.githubusercontent.com/VauntDev/tqla/main/.vaunt/mas_tqla.png
      description: uno mas, dba..., one more, mas tqla!   
      triggers:
        - trigger:
            actor: author
            action: star
            condition: starred = true
  - achievement: 
      name: Tqla Worm 
      icon: https://raw.githubusercontent.com/VauntDev/tqla/main/.vaunt/tqla_worm.png
      description: not all bugs are bad!    
      triggers:
        - trigger:
            actor: resolved_by
            action: issue
            condition: labels in ['bug'] & reason = COMPLETED
  - achievement: 
        name: Tqla Sunrise  
        icon: https://raw.githubusercontent.com/VauntDev/tqla/main/.vaunt/tqla_sunrise.png
        description: a shining example of your contribution to tqla!    
        triggers:
          - trigger:
              actor: author
              action: pull_request
              condition: merged = true
              operator: "|"         
          - trigger: 
              actor: reviewers
              action: pull_request
              condition: merged = true

You can check out the icons here. You can learn how to showcase any achievement you have earned with Vaunt by visiting and reviewing our docs.

You can configure custom achievements on any GitHub repository by installing the Vaunt application through the GitHub Marketplace.

Go install it and vaunt your contributors!

Conclusion

In conclusion, tqla is a powerful tool for building dynamic SQL queries. Leveraging Golang’s text templating tqla can help you overcome several challenges when working with dynamic queries.

In short, Tqla offers the following

• Security: You can use text templating to generate SQL queries that are safe and secure. Tqla prevents SQL injection by replacing template variables with database placeholders.

• Performance: Text templating can help you to generate efficient SQL queries. Some query builders are not flexible enough to allow for the most optimal query. Tqla stays out of your way when building complex queries while still ensuring proper database argument parsing.

• Maintainability: Tqla allows you to consolidate your query logic into a single template. Other solutions require the separation of conditional logic from statement building. Tqla templates make it easy to express complex filtering and sorting criteria in your SQL queries.

To stay in the loop on future development follow us on Twitter or join our Discord!

Don't hesitate to make feature requests.

If you want to see more examples of tqla feel free to reach out to us on our Discordor through GitHub.

mas tqla! - VauntDev.