DEV Community: Kyle Harrison

Empowering Education Through Technology: Vyta Sponsors 10 Laptops for CoderDojo Craigavon

Kyle Harrison — Wed, 06 Sep 2023 19:26:31 +0000

In a world driven by technology, access to digital resources is a gateway to boundless opportunities. Recognising the importance of fostering digital literacy and education in our community, CoderDojo Craigavon is excited to announce it has received sponsorship of 10 laptops from IT Asset Disposition company, Vyta, to support CoderDojo Craigavon — a vibrant initiative that empowers young minds to learn coding and computational thinking.

From their headquarters in Mallusk, Vyta offers a fully comprehensive IT lifecycle solution across the UK & Ireland, covering a wide array of needs including the collection of redundant IT equipment, secure data wiping, WEEE recycling and refurbishing of IT equipment for reuse. Their approach isn't just about maximising value return; it's about minimising the carbon footprint associated with keeping hardware in the circular economy for as long as possible and ensuring that data security and compliance requirements are met with meticulous attention to detail.

Vyta shares CoderDojo Craigavon’s vision of harnessing technology for good by creating a nurturing space where young enthusiasts can explore the world of coding and computer science. By providing young people with the tools they need to excel in an increasingly digital world, CoderDojo Craigavon is paving the way for future innovators, programmers, and problem solvers.

“Through our sponsorship of 10 laptops, we hope to help CoderDojo Craigavon expand its reach and impact, benefiting more young minds”, stated Rachael Weir of Vyta.
_
These laptops will serve as invaluable resources for young learners, enabling them to access online tutorials, coding platforms, and educational resources. Each laptop represents a stepping stone towards unlocking creativity, inspiring a generation of tech-savvy individuals who are equipped for their futures.

At CoderDojo Craigavon, we invite you to join us in supporting initiatives that harness the power of technology for education. Together, we can build a brighter, more inclusive future where every young mind has the chance to explore, learn, and create with confidence.

Sharing Github Labels across Repositories

Kyle Harrison — Fri, 03 Feb 2023 10:42:15 +0000

Labels (https://github.com/hackebrot/labels) is a CLI app for managing GitHub labels. It allows labels to be fetched and stored in a toml file (which can then be updated to include the required labels on another repository). Once fetched, the labels can then be synced to another repository.

Getting setup

pip install labels

export LABELS_USERNAME="apoclyps"
export LABELS_TOKEN=$GITHUB_TOKEN

Now you are ready to fetch labels from your chosen repository

Copying labels

labels fetch -o apoclyps -r reviews

This will create an output file in your current working directory called labels.toml

[bug]
color = "d73a4a"
name = "bug"
description = "Something isn't working"

[config]
color = "93447B"
name = "config"
description = ""

["contains: migrations"]
color = "EDFA48"
name = "contains: migrations"
description = ""

[dependencies]
color = "030750"
name = "dependencies"
description = ""

Syncing labels

To do a dry run using the -n flag to see what changes would be applied

labels sync -n -o apoclyps -r deps

This would delete the following labels:
  - yaml
This would update the following labels:
  - contains: migrations
  - dependencies
This would create the following labels:
  - config
This would NOT modify the following labels:
  - bug

If you are happy with the changes, rerun the same command without -n to apply the labels to the repository:

labels sync -n -o apoclyps -r deps

Chickity-check yo self before you wreck yo self!

Kyle Harrison — Tue, 06 Jul 2021 08:08:35 +0000

Have you ever found yourself in a situation where you pushed a commit to a branch for review, only to discover you made a spelling mistake, used outdated syntax, or forgot to lint your code again after making that one last change?

I've wasted countless hours in the past doing exactly this! It is slow and time-consuming to identify an issue after the fact and it also slows down other folks in your team performing the code review. There must be a better way!

Pre-commit solves this problem by providing pre-commit hooks that run after every commit which solves all of these common, repeatable problems that machines are good at solving.

However finding an awesome new tool to enhance your workflow is only half the challenge, convincing one or more teams to adopt it another.

Using a tool - without imposing it upon a team

Using pre-commit requires a .pre-commit-config.yaml to be placed in a repository however to avoid updating the .gitignore file for every new repository you wish to interactive with, the best solution i found was to add the following to a global .gitignore.

> vim ~/.gitignore

.pre-commit-config.yaml
.codespellrc

This allows for the file to be ignored from all repositories I interact with, without the risk of potentially committing it or needing to update the repository to use it. This is especially useful when I need to add confirmation files for some of the additional pre-commit hooks that I'm using such as codespell.

Finally within your repository you can create and use use pre-commit:

---
# .pre-commit-config.yaml
# ========================
#
# pre-commit clean
# pre-commit install
# pre-commit install-hooks
#
# precommit hooks installation
#
# - pre-commit autoupdate
#
# - pre-commit run black
#
# continuous integration
# ======================
#
# - pre-commit run --all-files
#

repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.0.1
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: debug-statements
      - id: check-merge-conflict
      - id: sort-simple-yaml
      - id: fix-encoding-pragma
        args: ["--remove"]
      - id: forbid-new-submodules
      - id: mixed-line-ending
        args: ["--fix=lf"]
        description: Forces to replace line ending by the UNIX 'lf' character.      
      - id: check-added-large-files
        args: ["--maxkb=500"]
      - id: no-commit-to-branch
        args: [--branch, master]
      - id: check-yaml
      - id: check-json
        files: ^tests/app/
      - id: pretty-format-json
        args: ["--no-sort-keys", "--autofix"]
        files: ^tests/app/

  - repo: meta
    hooks:
      - id: check-hooks-apply
      - id: check-useless-excludes

  - repo: https://github.com/ambv/black
    rev: 21.5b1
    hooks:
      - id: black
        language_version: python3.9

  - repo: https://github.com/PyCQA/bandit
    rev: 1.7.0
    hooks:
    - id: bandit
      description: Security oriented static analyser for python code
      exclude: tests/|scripts/
      args:
        - -s
        - B101

  -   repo: https://github.com/codespell-project/codespell
      rev: v2.1.0
      hooks:
      -   id: codespell
          name: codespell
          description: Checks for common misspellings in text files.
          entry: codespell
          language: python
          types: [text]

  -   repo: https://github.com/asottile/pyupgrade
      rev: v2.19.4
      hooks:
      -   id: pyupgrade

If you also want to use codespell, you will need to add a .codespellrc file to the root of your repository:

[codespell]
quiet-level = 3
count =
check-hidden =
check-filenames =
enable-colors =
builtin = clear,rare,informal,code,names
ignore-words-list = pullrequest

Now that pre-commit is configured, you can install and run it:

pre-commit install

pre-commit run --all

Trim Trailing Whitespace.................................................Passed
Fix End of Files.........................................................Passed
Debug Statements (Python)................................................Passed
Check for merge conflicts................................................Passed
Sort simple YAML files...............................(no files to check)Skipped
Fix python encoding pragma...............................................Passed
Forbid new submodules....................................................Passed
Mixed line ending........................................................Passed
Check for added large files..............................................Passed
Don't commit to branch...................................................Passed
Check Yaml...............................................................Passed
Check JSON...........................................(no files to check)Skipped
Pretty format JSON...................................(no files to check)Skipped
Check hooks apply to the repository..................(no files to check)Skipped
Check for useless excludes...........................(no files to check)Skipped
black....................................................................Passed
bandit...................................................................Passed
codespell................................................................Passed
pyupgrade................................................................Passed

Lastly, if pre-commit is ever blocking your workflow and for any reason you don't want to run it, you can append a --no-verify flag onto your commit to skip it.

git commit -m "do the thing" --no-verify

Now all your future commits are protected from common gotcha's and save time in code review.

Release your Software already!

Kyle Harrison — Thu, 03 Jun 2021 20:59:33 +0000

Are you struggling to keep on top of multiple pull requests across multiple Github repositories from multiple teams? This was my experience when I joined a new company and a normal workday involved reviewing several pull requests across one or more repositories that my team and I were responsible for reviewing and maintaining. Code review is a great blocker to releasing software when the code review session has gone stale and requires frequent check-ins.

As my team and other teams grew, so did the number of features, repositories, and code reviews; it became apparent that software was taking a longer time to ship, and on a rare occasion pull requests were opened for several days without review due to the difficulty of keeping on top of everything. It wasn't uncommon either for a few Dependabot pull requests to be forgotten about for several months because they just weren't visible through all the noise.

I found using a combination of GitHub dashboards, slack channels and 3rd party programs (like Trailer) for notifications was a great start; yet I still found myself routinely falling back to manually checking open pull requests several times during the day. Identifying changes was laborious and frequently there was no update since my last check. It was clear this was never going to scale, as more pull requests equals more simultaneous reviews.

Releasing software is comparatively much easier to measure than tracking the "real" time spent on code review. Stale reviews cause burnt cycles and delays releasing software because of inactivity; coordinating reviews in a timely and efficient way ensures features, enhancements, and fixes get shipped without delay and that all begins with improving visibility.

Let's build an MVP

Reviews to the rescue!

Reviews is a terminal UI dashboard to monitor requests for code review across Github repositories.

It began life as a simple script to list all open pull requests for a single repository, then several, and quickly evolved to do more as time went by.

The goal was to create a CLI dashboard that would poll Github for updates. Using configuration provided by a user, reviews would “watch” and render updates such as approval status, ability to merge, time the pull request has been opened, and more. This was the original idea for reviews; It has grown a little since then.

The technology behind Reviews was simple and minimal:

click for cli
rich for layout
pygithub for using the Github API

A quick mock up of the UI looked like this for the MVP:

followed by an initial spike using the libraries listed above, the first incarnation of Reviews was born and it looked a bit naff!

The first release

At an internal hackathon a work, I pitched the project and managed to convince at least 1 other person to join me on the project.

Over 2 days we worked on making improvements and trying to produce something usable as a 0.1.0 version of Reviews. Back then it was called Dexi (after an energetic 3 year old said it sounded like a pokedex). It mostly worked, but it was slow, prone to errors, and had huge sections in the TUI that did nothing yet. I didn't see anyone else using it except for me for the foreseeable future.

The strangest thing happened next ; after a quick demo, people seemed to like the concept and a few folks asked how to install and use it.

Embarrassed by the hacked together code; I held off on open-sourcing it for a bit, but the next iteration was better. code-review-manager was created at version 0.1.1. It fixed several bugs, errors, code quality issues, and empty sections of UI. It was not perfect, I was still slightly embarrassed to share it at this early stage, but I figured 1-2 people viewing the code couldn't hurt.

Project Growth

As the star count began to increase on the repository from friends and co-workers, I made a post on Reddit to find contributors who might be interested in helping with the project. It gained a lot of attention and invaluable feedback was provided via feature requests.

Afterwards, reviews got an honourable mention in PyCoder's Weekly Issue 472

The above attention helped push reviews forward from 0.1.1 by 11 releases to the current 0.2.0 release and even managed to spawn a simple website: https://reviews-cli.dev/

Conclusion

If I waited until I was 100% happy with reviews, it still wouldn't be released today but I have been using Reviews daily as an enhancement to my original workflow and others have started using it too. I get to spend less time checking for stale reviews, and more time on active code review which has been a huge win.

Reviews released 0.1.5 on PyPi

Kyle Harrison — Sat, 08 May 2021 14:54:35 +0000

Reviews is a terminal UI Dashboard for monitoring requests for code review across several Github repositories and pull requests.

It's been a personal project I've been incrementally adding to over the past few weeks and it's been paying off 10x. In a normal workweek, it can be time-consuming to keep on top of several teams, across several repositories, and track who needs a code review, and which code reviews are complete and ready to ship.

In the latest release, it's even easier to see which pull requests you have approved, and which have been approved by others.

If you are interested in using the TUI, want to check it out, or even contribute the source code is freely available on Github (https://github.com/apoclyps/reviews) and it can be installed directly from PyPI.

Want to get started right away? Check out the following snippet:

export GITHUB_USER="your-github-username"
export GITHUB_TOKEN="your personal github token used for interacting with the API"
export REPOSITORY_CONFIGURATION="apoclyps/reviews"

pip install --upgrade reviews

reviews dashboard --no-reload

Release discussion and changelog on Github: https://github.com/apoclyps/reviews/discussions/91

A simple terminal UI dashboard for code review

Kyle Harrison — Fri, 16 Apr 2021 16:19:04 +0000

Reviews is a simple code review manager that lists the status of open pull requests across multiple organizations & repositories as a terminal UI dashboard.

The project was created as a way to keep on top of multiple teams creating large amounts of pull requests across several repositories by having a single up-to-date view of the pull request's approval status and age.

The initial implementation can be found over on Github at https://github.com/apoclyps/code-review-manager and can be installed from PyPI: https://pypi.org/project/reviews/

Contributions and feedback are welcome. It's in the very early stages of development and it has a long way to go but hopefully, there is enough here for others to derive some value from it being released early.

Getting started with reviews

You can immediately start using review by installing it from PyPI and using providing the following configuration before running it.

pip install reviews

export REPOSITORY_CONFIGURATION="apoclyps/code-review-manager,apoclyps/my-dev-space"
export GITHUB_TOKEN="your-token"

reviews dashboard

Track your Bandwidth & Storage limits with our Quota API

Kyle Harrison — Tue, 08 Dec 2020 14:14:26 +0000

At Cloudsmith, helping fledgeling startups grow from a single person operation to enterprise-level organisations is a constant joy! In those early stages, startups need all the help they can get to survive, and even veteran organisations experience similar challenges when scaling up rapidly.

Cloudsmith can help with our self-service approach to managing and defining storage and bandwidth limits to keep costs under control while allowing you to scale when needed. After all, no one wants to be caught between an unexpected bill for overages or any interruption to their business, no matter how minor.

The fantastic news is that now you have a new tool in your arsenal, as you can track your bandwidth and storage programmatically via the Quota API. It's easy to miss an email when your busy or a prompt within the Cloudsmith UI (if you haven't needed to log in recently); but you will always want to know if you're near/over a limit or even if you're over-provisioned.

Now you can automate a solution that works for you using either our API or CLI to always stay on top of your storage and bandwidth limits.

Getting started quickly

Using the Cloudsmith CLI, you can quickly and easily view the usage, limits, and maximum allocation of bandwidth and storage for your plan.

cloudsmith quota limits ORG-NAME

Alternatively, if you want to view the entire history for your organisation:

cloudsmith quota history ORG-NAME

Finally, to view the OSS usage for an organisation, you can add the -oss flag to any command to view only OSS limits and history.

cloudsmith quota limits ORG-NAME -oss
cloudsmith quota history ORG-NAME -oss

If you identify a limit that is over-provisioned or quickly approaching a threshold, then you can quickly and easily adjust your limits at any time within the Cloudsmith UI.

Additionally, if you wish to automate a solution, you can also check out the Quota API or the Cloudsmith API Bindings (available in multiple languages) and connect it to your favourite CI/CD or monitoring service to alert internally within your organisation.

Restore authority with Token Bandwidth Controls!

Kyle Harrison — Tue, 06 Oct 2020 16:33:15 +0000

Now you can go beyond measuring your bandwidth usage and regain control via Cloudsmith's new bandwidth controls for Entitlement tokens. You can craft tokens with individual usage limits using the UI, API, and CLI, allowing you to decide the exact level of usage for each token.

Combining the new and existing limits for entitlement tokens, allowances are configurable to provide fine-grained control for any combination of properties. For example, the total amount of bandwidth, number of unique clients using a token, or the maximum number of downloads a token can perform on an individual token basis. Also, you can also scope your tokens by restrictions for advanced control of tokens.

If you are a vendor, you may want to have tiered levels of tokens for different users. Providing higher or even potentially unlimited allowances to your premium users is now possible, whilst maintaining control of your offering to free users with suitable limits. The best part is you can provide a lifetime limit for a token, or you can configure a refresh period to refresh the limits after the period has elapsed. For example, a token with a 1 GB daily limit, will allow up to 1 GB of daily usage and no more. After 1 day has passed, the token will be reset allowing another 1 GB of daily usage.

How it works

Within the Cloudsmith UI for Entitlement tokens, you can edit individual tokens to provide visibility restrictions, usage limits, or even provide additional metadata on the token for your own internal requirements.

To provide a bandwidth restriction with a refresh period. You will need to select a unit of Bandwidth e.g., GB, and enter a corresponding unit of bandwidth you would like to restrict by (e.g., 1GB of bandwidth). A "Monthly" refresh may be more than enough for most users but may prevent misuse of tokens by users accidentally using many TB's of data per month.

In this example, fine-grained bandwidth controls will be configured for the amount of bandwidth usage that token is allowed to consume every month. This is accomplished by selecting a few preset values and entering a bandwidth amount within the Edit Entitlement Token form.

To configure a 1GB bandwidth limit that resets monthly.

1. Select "Monthly" for "Refresh Token"

(Presets provide values from "Never Reset" to a range between "Daily" to "Annual")

2. Enter a number to Restrict by Bandwidth.

The number should be between 0 - 1000; you can go higher than 1000; however, the unit of bandwidth provides sensible defaults to keep values readable. (e.g. 1000000 bytes can instead be expressed as 1 Megabyte).

3. Select a Unit of Bandwidth.

Values range from a single Byte to an insanely large number of Petabytes.

Finally, select Edit to save your changes to the token. These restrictions will take effect almost immediately.

If you wish to set your limits programmatically, entitlement restrictions are configurable using the Entitlements API.

Finally, the easiest way to get started with making programmatic changes to entitlement tokens and applying restrictions is via the Cloudsmith CLI. Using the following command, you can set all visibility restrictions and usage limits for an entitlement token:

cloudsmith entitlements restrict OWNER/REPOSITORY/TOKEN_IDENTIFIER  --RESTRICTION

For Example:

cloudsmith entitlements restrict demo/example-repo/GYwg00eEElKs \
        --limit-bandwidth=1 \
        --limit-bandwidth-unit=gigabyte \
        --limit-num-clients=10 \
        --limit-num-downloads=1000 \
        --limit-package-query="package-darwin-amd64"  \
        --limit-path-query=tag:latest \
        --limit-date-range-from=2020-01-01T00:00:00Z \
        --limit-date-range-to=2077-01-01T00:00:00Z \
        --refresh-token=daily

It's that simple to get started!

Vendors Rejoice! Analyse your Bandwidth Usage

Kyle Harrison — Tue, 29 Sep 2020 15:13:29 +0000

As a vendor, understanding your bandwidth usage is an invaluable insight into how packages are distributed across your user base and how specific users have grown over a timeframe.

As a user base grows from 10s, 100s, and 1000s of users and package downloads are many multiples of your total number of users, it's essential to understand the distribution of your bandwidth utilisation by a user (or more precisely, entitlement token's) to aid in the identification of token's that make up a large percentage of your overall traffic.

When providing an entitlement token to a user under a specific license, you trust an entitlement token will be used to download packages upon the agreed-upon terms. However, an increase in your total bandwidth may start off slow and continuously grow over several months until it's suddenly become a massive increase in your overall bandwidth. Understanding this usage and precisely where this growth originates helps identify where/where change occurs and provides options to mitigate runaway bandwidth from specific entitlement tokens by changing how those specific users are managed.

How does it work?

Whenever a user downloads a package via an entitlement token, the exact number of bytes transmitted from our servers to the user host is stored for that specific token as an individual log entry. At the end of each day, we calculate the total bandwidth for every user across all of our repositories containing one or more packages and store the result as a daily aggregated value representing bandwidth usage.

The easiest way to get started exploring these metrics is to check out the metrics command within the Cloudsmith CLI. Alternatively, to get more fine-grained metrics, you can implement a programmatic solution using our API or one of the API binding libraries published in various languages.

Getting started quickly! Using the Cloudsmith CLI you can quickly and easily query the total bandwidth usage for your repository by running the following command with your organisation/repository:

cloudsmith metrics tokens OWNER/REPOSITORY

For Example:

cloudsmith metrics tokens demo/examples-repo

The following screenshot shows an example repository containing a number of active and inactive entitlement tokens alongside the total bandwidth used. The statistics table provides a simple insight into min/max/average token usage.

You can also retrieve usage metrics for one or more specific tokens by providing a comma-separated list of Entitlement token identifiers:

cloudsmith metrics tokens cloudsmith/example --tokens=ZGCV58VqT8Sl

If you wish to drill down further into a specific period of usage for a token, you can supply time and date for the start and finish parameters to filter for usage within that period. In this example, a single token is displayed for all of 2019:

cloudsmith metrics tokens cloudsmith/example --tokens=ZGCV58VqT8Sl --start=2019-01-01T00:00:00Z --finish=2019-12-31T00:00:00Z

It's that simple to get started!

You can find more information about Entitlement Tokens in our documentation.

Automating your remote working setup!

Kyle Harrison — Thu, 03 Sep 2020 21:36:51 +0000

Upon reflecting over the past 6 months of daily remote life, I've learned some very important lessons. The abrupt switch to remote working has been an interesting transition and I was completely unprepared for it. These are my insights from my experience thus far and how I employed a little automation to help.

Routine

With no daily commute, the ritual of performing mundane actions whilst preparing yourself for the day ahead was completely gone. Re-establishing this routine took a little bit of time but eventually what worked for me was simple; I grabbed a bowl of cereal, started an Alexa routine to "Wake up" my office, listened to the radio, and browsed some news sites during the time I would be travelling to the office.

I started with an Amazon Echo and eventually upgraded to an Echo Show.

This routine played a sci-fi engine booting up whilst the lights and fan turned on in the office, followed by a quick weather report, and finally a DJ on Planet rock kick-started the morning off with light conversation and rock tracks.

Natural Light

Through a combination of "lockdown", living in the inner city, and remote working, it's was all too common to go days without --much- - any natural light. It's incredible how much your focus can be affected when the lighting is too bright, too dim, or it just feels completely wrong for that time of the day!

I picked up a Kasa Smart Bulbs by Tp-Link for my office which allows control over the Brightness and Color/White Illuminance via an App or one of many libraries (such as python-kasa. Adjusting the bulb from daylight (9000k) in the morning to a dim incandescent (2500k) in the evening combined with F.lux has made an incredible difference to my focus.

Tracking Time

It's easy to lose track of time, tasks, and meetings when there are no interruptions and you're focused on a task. I've been guilty of missing a meeting or two until I started setting reminders and TODOs

Using a mix of Todoist, Google Calendar, and Pocket this has helped manage everything from short term tasks (don't forget to review code for x), to work meetings about to happen, and even articles to read whilst waiting for a build/deploy to complete.

Todoist integrates perfectly with the Echo Show and is a great way to check off remaining tasks during downtime.

Google Calendar is also great for providing reminders on and checking what's coming up - I even use it for family events.

Pocket is a nice addition for planning some reading for downtime. Simply add links and it will save a preview and how long it takes to read on average for you to pick up later.

Physical Setup

Finally, the last piece of automation that made a huge difference was improving my desk & monitor setup. The daily struggle of swapping HDMI cables between my personal computer and work laptop became a real struggle. Cables would frequently get tangled, fall behind my desk, and every morning was a pain to get setup.

I picked up some Invision Monitor Arms and UGreen HDMI Switchers to automatically switch screens without needing to remove/attach HDMI cables.

What's next?

Equipping yourself to work remotely is expensive and although there is a lot you can do on a small budget, there are some items that are always expensive. The following are some ideas I have for future automation when my budget allows it:

Add a routine for working in standing/sitting positions with Jarvis Standing Desk
Create workflows using the Elgato Stream Deck for deployments & routine tasks that cannot be triggered via Alexa.
Automated ring light for meetings - although a much cheaper alternative to Elgato Key Light.

Cloudsmith Now Supports Conan!

Kyle Harrison — Wed, 26 Aug 2020 10:40:14 +0000

We’re delighted to announce that Cloudsmith now supports Conan!

As most of your know, Cloudsmith is universal. It is our aim to support all the languages and package formats our customers and prospective customers use. We think any organization benefits from being able to store, secure, manage and distribute ALL of their software assets in a single consistent manner.

That doesn’t necessarily mean multi-format repositories, but rather every member of the team knowing where to find the packages they need and being able to integrate them into build and deployment processes in the same way - no matter what format.

Of course, there are a lot of formats and languages out there. So we never stop working to ensure that we cover as many as possible. We listen and respond to our customers, all with the intention of building the only truly universal cloud-native package management platform.

Hence our support for Conan. Now on with the detail...

Introducing Conan

Conan is an open-source package manager for C/C++, including everything from its client to server implementation and even documentation.

It is actively developed on GitHub by an awesome community of contributors and a team of engineers working full time on the project. C++ and C popularity continues to hold a steady spot at 9th and 11th place in the "most popular programming, scripting and mark up languages" category of the 2019 Stack Overflow developer survey. Additionally, they hold the 6th and 9th place in the most popular programming languages on Github for 2019, demonstrating the C/C++ community's longevity.

Conan is an excellent choice as a package manager. It provides the flexibility developers crave in a developer tool. It uses Python-based package recipes for extensibility, customization and integration with other systems.

It also works on a multitude of systems; including Windows, Linux (Ubuntu, Debian, RedHat, ArchLinux, Raspbian), OSX, FreeBSD, and SunOS. It can target any existing platform, from bare metal to desktop, mobile, embedded, servers, cross-building and works with a range of build systems (Visual Studio MSBuild, CMake, Makefiles, SCons, etc), with extensibility to use any build system. When combined, these aspects of Conan make it an excellent choice as a multi-platform package manager.

Using Conan with Cloudsmith allows development teams to:

Develop packages internally and share them privately with other teams.
Distribute and deploy your packages in a pipeline at your organization.
Distribute packages as commercial software.
Make modifications to public packages, choosing how you wish to republish (open-source, public, private).
Capture the exact state of your dependencies at a particular version, release, user, and channel.
Control (allow list/deny list) at an organization, repository, and package level
In short, all the benefits of using Cloudsmith that are already enjoyed by development teams all over the world today, are now available for Conan.

Getting Started

Getting started with Cloudsmith and Conan couldn't be simpler. First, you'll need a Cloudsmith account and a repository to which you can upload your packages. If you need to install Conan you can find instructions on the Conan website.

Cloudsmith should work with all supported versions of Conan, but we recommend using at least Version 1.25.2 or later for the best experience. You can check your local version like so:

$ conan --version

Conan version 1.25.2

Creating a Conan Package

For the purpose of this demonstration, we will create a Conan package containing a single function that prints "Hello World" using the official example. Running the following example will create a new package called "hello" at version "0.0.1" without the optional user/channel.

The Conan create command is equivalent to running export, install, and test.

$ mkdir mypkg && cd mypkg

$ conan new hello/0.0.1 -t

$ conan create .

The conanfile.py generated as part of the above command will be used to by Conan to build packages however it will also be used by Cloudsmith to retrieve metadata related to a package such as the package name, version, license, etc which can be used for advanced filtering using the UI and Cloudsmith CLI.

If you wish to learn more about how Conan creates the Package Recipe and Test Packages, the official documentation provides a detailed breakdown for each command. You're now ready to upload your package to Cloudsmith.

Uploading your Conan Package

First, you need to add a remote for a specific namespace/repository to the list of Conan remotes. The below example uses Cloudsmith as the namespace but this could be your namespace or one of an organization in which you are a member.

$ conan remote add cloudsmith-testing-public

https://conan.cloudsmith.io/cloudsmith/testing-public/
Once a remote has been added, a user can then be configured using your Cloudsmith username and password in place of the substituted values:

$ conan user -p PASSWORD -r cloudsmith-testing-public USERNAME

Once you're remote and user has been configured within Conan your token will be cached in the client until it expires or becomes invalid. You're now ready to upload your package:

conan upload hello/0.0.1 --all -r cloudsmith-testing-public

Once uploaded, you can view your package in Cloudsmith.

It's that simple to get started with Conan on Cloudsmith

In Conclusion

Cloudsmith provides fully featured Conan package repositories on all plans, flexible enough for use whether you’re hosting public packages for a public or open-source project, or private packages for your company’s internal needs. We're extremely proud to be able to support the C/C++ ecosystem with this tooling.

You can find further, context-specific information, including detailed setup and integration instructions inside each Cloudsmith repository.

Why wait? Get your public and private Conan package repository hosting at Cloudsmith now.

A month-long celebration to open source projects: coming soon!

Kyle Harrison — Tue, 28 Jul 2020 12:34:12 +0000

Yes, you guessed it! Hacktoberfest 2020 preparations are already underway globally. If you're not familiar with the event, it's a month-long celebration of open source during October by Digital Ocean. Hacktoberfest promotes contributions to a diverse range of open source projects on Github and welcomes for first-time contributors to get involved with the community.

It's easy and the perfect time to get involved or even to rejoin the open source community. If contributing to your favorite open source project sounds appealing, wait, because it gets even better! Hacktoberfest is open to everyone across the world. Contributors can sign up anytime between October 1st and October 31st to become eligible for fantastic swag in the form of t-shirts and stickers from Digital Ocean. Submitting four quality pull requests to a public Github repository qualifies each contributor to swag, and what fantastic swag it is! Check out last year's fantastic t-shirt!

At Cloudsmith, we use open source tools and dependencies in all of the software we build and use daily. We love giving back to the community and frequently contributing enhancements and bug fixes to libraries and package management tools to help our customers and our own internal needs.

Helping to support the open source community is important to us. That's why we provide free, open-source repositories for all our package formats and provide open source tools to help users get the most out of Cloudsmith as their universal package repository.

This year, like many previous years, will see members of the team contributing to a range of open source projects for fun and to scratch our own itch by making something we love even better. Still, we're all about giving back and want to help empower developers to contribute to tools they enjoy using. That's why we will be creating a range of issues suitable for first-time contributors and experienced developers to make code and documentation improvements across some of our open source projects:

As a team, we are looking forward to engaging with the community we love, and creating new awesome software together!