For business inquiries please contact us via hi@zero10.app ⠀ ZERO10 is the leading AR Fashion Platform providing innovative tech solutions for brands entering the digital world. We believe that the future of fashion is hybrid, where physical and digital goods are blended into one united experience. Our proprietary wearable technology allows fashion brands and retailers to expand their customers’ journeys and increase engagement.

ZERO10

zero10

Navigation with Large Language Models: Discussion and References

According to Euromonitor and McKinsey, the revenue of the global fashion industry is $1.7 to $2.5 trillion, which makes it one of the biggest industries in the world. But it is also highly traditional and slow-moving in terms of technology. However, some entrepreneurs believe that this can be changed. I have talked to George Yashin, CEO & Co-Founder of , the leading AR-fashion platform providing innovative tech solutions for brands entering the digital world,  on the idea behind the project and current tech trends that will disrupt the world of fashion. ZERO10 Where did the idea for ZERO10 come from? What inspired you to create an app for users to try on digital clothes in real time and collect them in a digital wardrobe? At first, there wasn’t a specific plan to launch an app or a platform. This decision was a natural consequence of a concept taking shape. The concept itself was a result of my experience, working in fashion for many years and seeing all the problems and particularities of the industry. I’ve come to the realization that I want to impact the fashion industry and make it more sustainable by eliminating the necessity to make material clothes. It seemed that the most logical alternative to physical clothing was 3D digital apparel. However, 3D models can’t substitute tangible items because you can’t try them on. Coming to this idea, our team started to think of ways we could create the illusion of the flesh and blood of a real human wearing digital clothing. There are two methods of placing virtual clothes on a human’s body ― overlaying digital pieces on a photograph of that person or fitting them digitally in real time. The first tactic was and still is popular among some players on the market. Their design teams render 3D models of clothing and place them upon users’ photos with such software as clo3D and Photoshop. The process may require a few hours or even a couple of days and can be called manual because it must be done by a specialist each time. As a result, the client gets a ready-made picture with them wearing the digital piece and can use it on social media, but only on social media. We didn’t want to turn to this method because there wasn’t any unique technological solution behind it, thus it wouldn’t revolutionize the fashion industry. An even more considerable objection was that it had nothing to do with the physical fitting. We knew exactly what direction we wanted to move in and started to work on our own real-time try-on technology. But then there was another issue to resolve; to give users the possibility to try digital clothes on, we needed to provide them with the clothes. Moreover, for virtual apparel to be interesting, it wasn’t enough for it to be a technological advancement. We needed pieces that would be valuable to customers because of their uniqueness and the designer behind them. As it was crucial for us to allow real-time fitting, we needed to develop a process that would be smooth and resemble the experience in the physical world but that could be accomplished. Our focus on users’ needs and behaviors instead of brands impacted the product and shaped our decision to build a marketplace where brands would showcase and sell their items, and a digital wardrobe for users to keep the purchased items. It seemed that the most logical and convenient embodiment of that concept was to make it into an app because users could easily use it for fittings, choosing and storing virtual items, and sharing their content on social media. Shifting the main focus from users to fashion brands, ZERO10 provides innovative tech solutions for brands entering the digital world. What's the main difference? We believe that the future of fashion is happening now. So, we haven’t just developed our product for the present, but we're also laying the foundation for it to be widely used in the future. In the beginning, we saw people who would purchase digital clothing as our end users, but after a few months of work we’d come to understand that many of them were not ready yet to make digital fashion a part of their everyday living and exchange tangible pieces for virtual ones. Today they use AR to try clothes on but only for the sake of fun and creating content for social media. We’ve noticed, though, that businesses — fashion brands and retailers — have started to show demand for AR and other emerging technologies. The business community has begun to see the power of these technologies resolve some of their problems: consumer engagement, omnichannel, personalization, conversion of users’ attention into purchases, etc. We firmly believe that we’ll be able to promote our technology among consumers through brands and companies that are opinion leaders for them. By creating this technology today, we’re not interested in getting a head start or trying to achieve quick results. On the contrary, we are working for the future of fashion by developing a one-of-a-kind technology that can be easily adapted to the market’s needs, be it virtual fitting of clothing for e-commerce now or putting together a wardrobe for a metaverse a year later. From our experience, it seems that the metaverse, Web3 and users as ultimate consumers are the future that will become real and monetizable but not for another 2 to 3 years. That’s why we create products for today but with our sights set on the future. Despite our recent pivot to B2B, we haven't given up B2C. On the contrary, we’re planning further developments in this direction. But, understanding the modern world and the market’s specifics, we’ll be transforming the way we work with regards to the end user. Take our latest project, the Open Call competition, which is aimed to attract digital fashion early adopters — digital fashion creators and 3D designers. The concept of the creative economy, where users simultaneously make and consume content, is what’s on the front burner right now, and it’s going to progress even more in the future. How can the B2B sector benefit from your technology? We see huge potential for the fashion business to implement AR clothing try-on technology. As the competition is growing between online and offline retail, both face certain problems. Currently, e-commerce is dealing with a huge number of returns and a low rate of users’ attention converting into purchases. It is a direct result of users having no chance to try clothes on before buying them, and such solutions like 360 product view or size guides are not efficient enough to change the situation. That’s why the implementation of digital clothing try-on technology can be helpful as it’s the counterpart of physical fittings. Our real-time try-on technology allows users to try on clothes the same way they would in the fitting room of a physical store. Offering brands and online retailers our SDK, a set of tools that allows e-commerce platforms to easily add AR try-on to their apps and websites, gives their customers the chance to try things on. The end result boosts customer confidence through the choosing process, and, consequently, sales increase. Today AR is being eagerly implemented not only in fashion but also by brands and companies that sell cars, furniture, shoes, beauty products and accessories via the internet. They do it to help their clients visualize how products will look on them or in their apartments and offices. The real-time try-on technology for clothing is the most complex and complicated part of the entire AR try-on sector because a human’s body has a lot of various characteristics, such as different shapes and types of figures. It directly influences the level of vividness with which a digital item looks on a human’s body in AR. At the same time, fashion is one of the biggest markets for the AR industry. In offline retail, AR helps to engage customers. Consumers are actively going back to offline shopping; the numbers are close to the pre-Covid time of 2020. But consumers have changed as they’ve become more active in online shopping and have gotten used to quick personalized service provided by e-commerce. Also, it’s important to think of the preferences of the new generation of customers that is Gen Z. Even though they extensively use technology, they still visit offline stores, mostly for the sake of the experience. Brands and retailers should be looking for new approaches to keep customers coming back to their physical spaces. AR try-on technology is one of the possible solutions for that. How do you enter into partnership with clothing brands? Who usually initiates it, and what are the requirements for a brand to get their items digitized by ZERO10? It was hard to persuade brands to work with us in the beginning. We set our bar high from the start and decided to work with well-known designers and avoid the no-names in order to create additional value for the users. We wanted to let them try on pieces by their favorite designers and at the same time give brands the opportunity to try their hand in digital fashion. At that time the discussion around virtual clothing had just started in both media and the industry, and most of the brands were not ready for it and didn’t understand the benefit. However, in about a year the situation had changed drastically. The concept of AR try-on had become a popular topic in mass media, and brands had come to the realization of how it could be useful for their business. Besides, by that time, we had significantly improved our technology since its launch. Developing our own technology allows us to create more solutions and products so that we don’t have to limit ourselves to being an app with designers’ showcases. Now a lot of brands contact us directly. What makes ZERO10 technologies different from other popular solutions on the AR-fashion market? One of our main advantages is the unique combination of experience coming from a variety of fields ― tech, fashion, and product development. Such a mixture of backgrounds allows us to develop a technology that doesn’t exist in a vacuum and is applicable and feasible for the fashion industry, which helps to solve the existing problems of business and meet the needs of brands. If our team had just a tech background, we wouldn’t be able to create a product like this because we’d lack the understanding of the market. Developing the technology for virtual try-on and creating AR-enabled garments, ZERO10 is a full-cycle company. The ability to oversee all these processes in-house, and being fully in touch with the team on every stage of work is also an advantage. Also, we utilize the recent innovations in computer vision and computer graphics and have a team of world-class engineers. At the moment, there are only two companies with their own AR clothing try-on technology on the market. To distinguish our product from our competition, we constantly improve the quality of virtual fitting in order to achieve the likeness of the experience to the physical one. It’s a widely known problem that AR try-on technology is in its early stages of development and, as a result, digital clothes often don’t look the same on a person as tangible items do in real life. It certainly drives away many users who want to create high-quality content, as well as luxury brands because the visual aspect, the way a piece of clothing looks, is crucial. It’s extremely important for them that the digital version of each item should look as close to the real thing as possible. We share this approach, and, to achieve this, we pay a lot of attention to developing our fabric simulation technology which helps digital clothes look as vivid as possible, down to the smallest details ― textures, materials and movements. How does Cloth Simulation work? What technology did you use to get an accurate look on the body, and what difficulties did you encounter? Cloth Simulation is one of the core technologies of the ZERO10 Try-On that replicates the natural flow of fabric from human body interactions. The same technology is used in the gaming and movie industries. However, our task was more challenging because we needed to simulate clothing in real-time on a mobile device. We have done a lot of optimizations to run cloth simulation on a GPU. GPU, or Graphics Processing Unit, is a special electronic circuit that has been designed for computer graphics tasks and later, generalized for other tasks. GPU’s main advantage is that it can perform more arithmetic operations than the Central Processing Unit (CPU). However, writing effective programs for GPU (called shaders) requires deep understanding of the internal workings of the GPU and experience. We also use shaders to simulate various materials, like fur, leather or jeans, and create visual effects, like burning. What is body segmentation and why was it essential to develop such technology? Real-time body segmentation is used in a range of different applications. For example, body segmentation is used during Zoom calls to hide the background. At ZERO10 we are working on multi-class body segmentation that allows us to segment different parts of the human body, including hands, face, hair, etc. These segmentation marks let us create a more realistic AR Try-On experience. For example, we use hand segmentation to make sure that virtual clothing does not hide the hands if they appear in front of the body. Developing a high-quality body segmentation requires: . Data is one of the most important ingredients for creating high-quality ML models. We put forth a lot of effort to obtain high-quality ground-truth segmentation marks. We use help from an agency to label a large number of images. We use a third-party agency to assist us in labeling numerous images. Collecting images and segmenting them manually . It requires a lot of computation and typically takes a few days on modern hardware. We use AWS instances with NVIDIA Tesla V100 GPUs to run many experiments in parallel. Training ML models . We do a lot of this. For example, last month Apple published a new backbone, called MobileOne, that is faster than the widely used MobileNetV2 architecture and leads to better results. We are planning to test it very soon. Experimenting with different model architectures . Modern iPhones have a special electric circuit for running ML models, called the Apple Neural Engine. It is available for iPhone XS and higher models (modern iPhones use more powerful ANE). However, not every ML model can be run on ANE. And not every ML model will run on ANE effectively. We need to do a lot of experiments to optimize our models for ANE. Optimizing our models for ANE (Apple Neural Engine) How can you describe 3D body-tracking technology? Have you encountered problems with data analysis from body scanners? 3D body-tracking technology helps us to understand the user's pose and body shape, which are necessary ingredients for a good fit. 3D body tracking is a very challenging research problem. There are a number of research papers on it published at the top Computer Vision conferences every year. The main reason that makes body tracking so difficult is our desire to make it work in 99 percent of cases. It is relatively easy to create the technology that works in 50 percent of cases, but it is challenging to make technology that works robustly across all poses and for all body shapes. Our technology does not use body scanners. We think it is an unnecessary extra step for our customers. We analyze the user’s body pose using the image from an iPhone camera. What are the next goals for ZERO10? Are you planning to add new features? Since we've pivoted to B2B, our team has been actively developing new products for retail, both e-commerce and physical stores. At the moment, we are busy preparing to launch our SDK for e-commerce, which will be out soon. For offline retailers, we are developing the concept of pop-up stores. We will showcase the project in New York in September. It’s going to be the quintessence of the physical and online shopping experience combined, but with digital-only items. It’s our first step toward developing innovative pop-ups. Later, we are going to present a completely new concept of digital retail spaces which doesn’t require any physical attributes, such as hangers or a cash register, or even any physical space at all. We believe that the future of shopping is inside the mobile device’s camera, not inside a website. Next year we are going to ramp up our efforts by turning our technology with AR try-on inside a camera into a new shopping tool.

Innovative Solutions That Will Change The Shopping Experience

10:12 A.M. 11OCT 2022 <system voice notification> “Hi Marc, I’m transferring $15K of your free-cash to investment-account and buying Amazon (AMZN) at $1621. Also, the home-insurance was renewed for 24 months. You saved $2400 in premium paid.” 03:45 P.M. 24 OCT 2022. <notification>: “You made a profit of $812 on AMZN transaction of 11Oct2022.” <update> “I’ve transferred $5K to Thomas and cleared $1200 on AMEX Card XX43. An updated investment portfolio report is in your inbox.” Not a fictional scenario but a very real possibility in the near term. Platform and processing power, data abundance, and advances in AI models are bringing us closer to a world where machines can do most of the things we thought only humans could do. In the near future, customer experiences will be centered around ‘ which automates and improves much of their’ financial lives and outcomes. self-driving finance’ These Intelligent-Assistants will work 24/7 to provide superior returns on our idle-money while mitigating risk. Also, recurring tasks such as bill payments, subscription renewals, and insurance will be automated to free-up consumers’ time and attention as algorithms make decisions on our behalf. The future of banking is a world without banks! Too radical? Let’s simplify it. Introducing Self-drive finance Autonomous finance reimagines the whole idea of financial services delivery by integrating technology at the heart of each system. Using AI and Machine Learning, ‘ ’ can remove human input from decision making, enabling every customer to have a virtual private banker making all financial decisions for them. Autonomous Finance As the financial-services industry rapidly modernizes with the introduction of real-time fund transfers, the proliferation of mobile apps, deployment of chatbots and AI-based solutions to manage customer complaints as well as API-led banking, the era of a customer making decisions about their money is behind us. Future applications will be designed around every customer’s unique journey, specific portfolio, and financial needs. The goal is to improve fund allocation, bring efficiencies and reduce the possibility of human error by letting advance algorithms run tasks such as portfolio management or bill payment automation. The digitization of everything and “changing is transforming digital-finance. The millennial' consumers already trust recommendations generated by AI on how to manage their finances. consumer expectations” The bonds that have historically held together financial institutions are weakening, and the operating models are being fundamentally reshaped. Autonomous-Finance is likely to have a massive impact on the ‘hidden’ cost of data and information asymmetries. Let’s take India for example: The entire banking industry’s retail-assets base is ~$350–370bn, however, consumers are losing (approximately): $10bn on higher borrowing costs in mispriced loans. $8bn in higher premium costs for Insurance. $10–20bn in lost interest income on ‘idle-cash’ in the bank account. Man and the Machines: “Systems of Intelligence” Even though humans historically - on the foundations of trust and legacy, have run the banking functions- the introduction of machines has changed the playing field. First, the rise of ATMs made customers brand agnostic as long as they could cash out at convenience. Then came the internet banking, where customers can quickly initiate money transfer or investment transactions from the comfort of their phone. We are currently in the third wave of digitization where intelligent algorithms are beginning to control everything from lighting in the living rooms to the temperature of our coffee. Why should finance be left behind? Imagine interacting with an “intelligent application” which advises you on personal finance, reallocates your investment portfolio according to your life-stages and goals. At the same time, it makes sure you don’t miss a bill by setting up auto-pay for all bills while considering the importance of maintaining a consistent level of liquidity for you. These “Systems of Intelligence” companies will create massive value. The value will not come from the “intelligence” alone. The value is in the system itself. Technology platforms are shifting. Financial transactions have moved away from legacy infrastructure to innovative buy-and-build models where supply chain financing happens through blockchain, mortgage onboarding happens through AI, and the risk analysis of portfolio happens every millisecond with reallocations taking place through Robo-advisors. This makes it possible to in a 360-degree fashion to ensure that money works for people autonomously in a reimagine product, service and consumer experience stack ‘self-drive’ mode. “The arrival of true autonomous finance will be the companies that provide the connective tissue between these sometimes competing needs, automatically monitoring and adjusting your financial roadmap over the course of your lifetime. “- Angela Strange The future is already here. In the era of ‘ and ‘ ’, the handling of finances will be outsourced to thousands of algorithms working seamlessly across a suite of services to provide an integrated and hassle-free experience. invisible banking’ autonomous- finance The application will realign to refinance our debts when it’s most advantageous in terms of interest rates and arbitrage opportunities. The system will invest our cash into longer-term investments (and rebalance them) when it makes the most financial sense. Life insurance and other such payments will be on autopilot, bills will be automatically paid and subscriptions managed seamlessly. Already, the line between deposits and lending is getting blurred and automation will further erode this distinction further as ‘ . Non-traditional data is opening up new vistas in this domain and cash flow-based lending models are now possible which serve new customer categories and markets. cash-flow will be delivered as a service’ While there’s a lot to look forward to when automated finance becomes everyone’s lived reality, the way things shape up will also depend on how regulations & policy evolve. A clear vision of the future financial landscape is critical to good strategic and governance decisions as financial institutions around the world face growing competitive pressure to make major strategic investments in AI, and policymakers seek to navigate the challenging regulatory and social uncertainties emerging globally. AI-driven finance: The challenge for fintech is one of consumer trust. With data proliferation and real-time data sharing across geographies, the data sovereignty laws might need to be revisited. At the same time, the fiduciary status of entities will have to be aligned with the legalities of the algorithms. Other issues that will crop up during the course of regulating the world of autonomous finance relate to digital identity, data privacy, transparency of practices and intellectual property rights. While AI-driven finance seeks to make lives easier and money management more efficient, the big challenge staring us (fintech companies) is that of establishing consumer trust. Consumers will seek to reward companies with their business which maintains transparency in policies, data integrity, and communication. Establishing consumer trust is a pivotal point in the journey of ‘autonomous-finance’ as it’ll determine the long-tail of products and services. “Technology goes beyond mere tool making; it is a process of creating ever more powerful technology using the tools from the previous round of innovation.” –Ray Kurzweil The paradigm shift in the nature of Money ( from Cowry Shells to BitCoin) Money is undergoing evolution. Paper money is a relatively new invention. In the near future, our most important financial decisions will be taken autonomously by computers and algorithms that we trust and rely on. The future experience of a consumer will be centered around where financial lives are automated and financial outcomes improve greatly. machine-driven finance The factors ) that were important to Incumbent financial institutions in remaining competitive are reaching equilibrium, and reducing their’ ability to differentiate. (PRICE, SPEED, ACCESS As it frees financial institutions from the need to make trade-offs between better service and cost, Autonomous-finance models will give rise to a new set of competitive factors ( on which financial institutions can differentiate CUSTOMIZATION, EXPERIENCE, ECOSYSTEM) . The line between deposits and lending will become blurred when Models become better as more data is generated, but the prediction value of any individual model and system tends to plateau. The key is to establish a link between better models and better products. Non-traditional data makes it possible to serve new customer categories and markets. “cash-flow is delivered as a service”. Also, will break down as one service-based offering manages the flow of customers’ money across multiple accounts. the demarcation between spending, borrowing and wealth management The creation of new connections between capital and assets will result in new pools of capital to access alternative assets. Deposit accounts are no longer the locus of control for customers as the center of the retail customer experience shifts to financial-management platforms. Technical breakthroughs happen slowly and then suddenly. People were a decade before the iPhone. We underestimate how long it takes for a breakthrough technology to fully develop and get adoption, but we also underestimate the scale of disruption. actively working on mobile computing We are in the early phases. Change is coming and it’s coming fast and it’ll only accelerate. and currently building a for India and South-East Asia. Gaurav Sharma is a finTech entrepreneur Bank of the Future Other posts by Gaurav: FinTech Wave-2 isn’t Digital, It’s Hybrid. Lessons from Wave-1 and What’s Next? Credit is older than Money (and Fintech) “Blood and Sand”: The Moment of -Truth for Mobile Wallets in Asia ChatB ots, API, Voice, Zero UI, and the future of Mobile Apps. Artificial Intelligence (AI) and FinTech — Part 1 Wal-Mart Moment for the banks Of Suits, Hoodies, and Ripped Jeans- Transcending the “Expectation Chasm” in Banking

“Autonomous-Finance” offers a Re-Imagined Idea of Banking.

Git in 2016

Nobody likes repetitive tasks. So why should you run all your tests manually with every new code or—even worse—check that the new code didn’t break your build process? Yeah, I know you want to spend your precious time on shiny features without having to waste hours tweaking your build pipeline. Or maybe you have excuses like “I would have to pay for the automation” or “It’s time-consuming to prepare pipelines, and I don’t have time for it.” It’s not necessary to spend hours setting up your automation pipelines. Check out this guide and spin up a GitHub Action for your favorite stack fast—like Stack Overflow copy & paste fast. TL;DR If you are familiar with GitHub Actions, you can skip the theory and jump to the specific stack in the Examples section below. Continuous Integration and Continuous Delivery Let’s start with the basics. The terms might sound very technical at first. However, the basic concept is quite simple. is the automation of building and testing. This means that typically, with some code changes, the machine checks whether it’s possible to build the project and whether your tests are passing. is a little bit broader. To sum it up, this automation process will deploy or publish your code to various environments. This might be a little bit abstract and connected with the nature of your project, but you can visualize it as publishing to package registries like NPM or Nuget—or deploying your site to a staging or production environment. Continuous integration Continuous delivery GitHub Actions GitHub Actions are the feature of GitHub that consists of the API and an environment for running your tasks. You just need to create a YAML file at a specific location in the repository. The configuration .yml file contains all the specific information about the environment, such as , , or . Additionally, you can choose the environment where you want to run your tasks—it might be Linux (Ubuntu), Windows (Windows Server), or even macOS (Big Sur or Catalina). trigger events jobs strategies The anatomy of the Action Each action is represented by a file located directly in the repository at the . To be able to run it, you need to allow the Actions feature in the repository’s Settings. .yml .github/workflows location Note: If you are not familiar with the YAML format, for the purposes of the GitHub Actions, you just need to know that key-value pairs are represented by key: value . The quotes for string values are optional. Nesting of objects is done by indentation (typically two spaces), and items of the array are denoted by a dash. key: value nested_property: Nested value my_array: - First Item - Second Item GitHub Actions basic syntax keys - The name of the workflow. name - Is required, specifies events when you want to run your action. on - A job is a unit of work; jobs run in parallel by default. Each job runs in a runner environment specified by runs-on. jobs - Is required, specifies the type of the machine to run the job. jobs.<job_id>.runs-on - A step is an individual task that can run commands in a job. A step can be either an or a shell command. Each step in a job executes on the same runner, allowing the actions in that job to share data with each other ( ). jobs.<job_id>.steps action definition by GitHub - Selects an action to run as part of a step in your job. This is beneficial for reusing existing actions. You can check existing actions in the official or on the . jobs.<job_id>.steps[*].uses actions repository marketplace - Provides a shell where you can run your commands. jobs.<job_id>.runs-on Hello World Action Let’s write the action that runs every day. This action will run on Ubuntu, using code from our repository, and will run our main.py script on the environment with Python 3.8. The explanation of each line is described in the respective comment directly in the code. the Python script Create in the root of your repository with content . main.py print("Hello, World!") In the create the file with the following content. .github/workflows minimal-action.yml name: Hello World From Python #  Represents the name of the whole action. on: # Specifies the section where we describe our build triggers. schedule: # Specifies the section where we describe the schedule of running the action. - cron: '* 1 * * *' # The CRON expression describing when to run the action. workflow_dispatch: #  Adds the ability to run the action manually by button on the Actions tab. jobs: # Specifies the section where we describe our jobs. hello_world_job: # Specific job section. name: A greeting job # The name of the job. runs-on: ubuntu-latest # Describes the environment. steps: # Specifies the section where we describe the job's steps. - name: Checkout # The name of the step. uses: actions/checkout@v2 # Using already existing action actions/checkout@v2. This action provides us with access to the code of the repository. - name: Set up Python 3.8 # The name of the step. uses: actions/setup-python@v1 # Using already existing action actions/setup-python@v1. This action sets up a Python environment for us. with: # Configuration of the python action. python-version: 3.8 # Specific python version. - name: Run the script # The name of the step. run: python main.py # Command for running our main.py. Real-world examples It’s not possible to cover all capabilities and combinations here. Nevertheless, in this section, you can find some real-world examples—you can choose them for scaffolding your Action quickly for your specific stack and use case. They showcase configuration for various languages, platforms, and publishing to external package repositories. However, before we start, we’ll need some more commands for these real-world examples. - Runs the action when a specific release event occurs. on.release.types - Runs an action when push or pull request event occurs on a specific branch. on.<push|pull_request>.<branches|tags> - Allows to set different job configurations. jobs.<job_id>.strategy.matrix - Context for specified environment variables. env - Specifies the location of stored . It’s a good practice to store secrets and keys to storage of the repository. env.NODE_AUTH_TOKEN NPM_TOKEN Encrypted Secrets - The job will run if the condition is met. jobs.<job_id>.if Build Node.js app and publish to the NPM registry The Action that builds the Node.js project written in TypeScript and publishes the package to the NPM registry when the release is created. The publishing of the NPM package is performed by the command. npm publish on: release: types: [published] name: publish-to-npm jobs: publish: runs-on: ubuntu-latest strategy: matrix: node-version: [14.x] steps: - uses: actions/checkout@v2 - name: Use Node.js ${{ matrix.node-version }} uses: actions/setup-node@v1 with: node-version: ${{ matrix.node-version }} registry-url: 'https://registry.npmjs.org' - run: npm install - run: npm run build - run: npm publish env: NODE_AUTH_TOKEN: ${{ secrets.NPM_API_KEY }} Build Ruby website and publish it to GitHub Pages The action that runs with push or pulls request to master. The action builds the Jekyll project and publishes it to a specific folder. After running this action, the site is accessible on . GitHub Pages name: Ruby on: push: branches: [master] pull_request: branches: [master] jobs: build: runs-on: ubuntu-latest strategy: matrix: ruby-version: ["2.6"] env: PROJECT_ID: ${{ secrets.PROJECT_ID }} steps: - uses: actions/checkout@v2 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: ${{ matrix.ruby-version }} bundler-cache: true # runs 'bundle install' and caches installed gems automatically - name: Update gems run: gem update --system - name: Install required packages run: gem install jekyll bundler kontent-jekyll - name: Build the output run: bundle exec jekyll build env: JEKYLL_ENV: production - name: Deploy 🚀 if: github.ref == 'refs/heads/master' # Checks if the current branch is master. uses: JamesIves/github-pages-deploy-action@3.6.2 with: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} BRANCH: gh-pages FOLDER: _site CLEAN: true # Automatically remove deleted files from the deploy branch Build the Ruby project and publish it to RubyGems The Ruby project is built and published to . This example uses action for publishing. RubyGems dawidd6/action-publish-gem name: publish-gem on: release: types: [published] jobs: publish: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: 2.6 - name: Install dependencies run: bundle install - name: Run tests run: bundle exec rake - name: Publish gem uses: dawidd6/action-publish-gem@v1 with: api_key: ${{secrets.RUBYGEMS_API_KEY}} Node.js app with tests The tests are performed by executing the command. npm run test:all name: Test on: [pull_request] jobs: build: runs-on: ubuntu-latest strategy: matrix: node-version: [14] steps: - uses: actions/checkout@v2 - name: Use Node.js ${{ matrix.node-version }} uses: actions/setup-node@v1 with: node-version: ${{ matrix.node-version }} - run: npm i - run: npm run test:all Node.js app with UI tests using a browser Sometimes the test environment requires a browser, and default virtual environments come with a lot of . This action runs tests directly in the browser using the command. preinstalled browsers npm run test:all name: Test on: [pull_request] jobs: build: runs-on: windows-latest strategy: matrix: node-version: [14.x] steps: - uses: actions/checkout@v2 - name: Use Node.js ${{ matrix.node-version }} uses: actions/setup-node@v1 with: node-version: ${{ matrix.node-version }} - run: npm i - run: npm run test:all PHP project using Composer and Codecov This action sets up the PHP environment on the Ubuntu machine using . Moreover, it validates and caches packages. In the end, it runs a code coverage tool by . shivammathur/setup-php@v2 Composer Codecov name: Build & Test & Report on: push: branches: [ master ] pull_request: branches: [ master ] jobs: build: runs-on: ubuntu-latest strategy: matrix: php-versions: ['7.0', '7.1' , '7.2' , '7.3' ] phpunit-versions: ['latest'] steps: - uses: actions/checkout@v2 - name: Setup PHP uses: shivammathur/setup-php@v2 with: php-version: ${{ matrix.php-versions }} extensions: mbstring, intl ini-values: post_max_size=256M, max_execution_time=180 coverage: xdebug tools: php-cs-fixer, phpunit:${{ matrix.phpunit-versions }} - name: Validate composer.json and composer.lock run: composer validate --strict - name: Cache Composer packages id: composer-cache uses: actions/cache@v2 with: path: vendor key: ${{ runner.os }}-php-${{ hashFiles('**/composer.lock') }} restore-keys: |
          $ -php- {{ runner.os }} - name: Install dependencies run: composer install --prefer-dist --no-progress --no-suggest - name: Coverage run: vendor/bin/phpunit --coverage-clover coverage.xml - name: Codecov uses: codecov/codecov-action@v1 Build, test, and publish to Nuget .NET Core package This example covers the release process of the .NET Core SDK package. The action restores packages, builds the solution, runs tests, and publishes artifacts to . Nuget name: Publish to NuGet on: release: types: [published] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Setup .NET uses: actions/setup-dotnet@v1 with: dotnet-version: 5.0 .x - name: Extract version from tag id: get_version uses: battila7/get-version-action@v2 - name: Restore dependencies run: dotnet restore - name: Build run: dotnet build --no-restore --configuration Release /p:ContinuousIntegrationBuild=true /p:Version="${{ steps.get_version.outputs.version-without-v }}" - name: Test run: dotnet test --no-build --verbosity normal --configuration Release /p:CollectCoverage=true /p:CoverletOutputFormat=opencover - name: Codecov uses: codecov/codecov-action@v1 - name: Pack run: dotnet pack --no-build --include-symbols --verbosity normal --configuration Release --output ./artifacts /p:PackageVersion="${{ steps.get_version.outputs.version-without-v }}" - name: Upload artifacts uses: actions/upload-artifact@v2 with: name: "NuGet packages" path: ./artifacts - name: Publish artifacts to NuGet.org run: dotnet nuget push './artifacts/*.nupkg' -s https://api.nuget.org/v3/index.json -k ${NUGET_API_KEY} --skip-duplicate env: NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }} - name: Upload artifacts to the GitHub release uses: Roang-zero1/github-upload-release-artifacts-action@v2.1.0 with: args: ./artifacts env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} Build, test, and publish Java project to Nexus registry In this Action, the package is built and published using . The package is deployed to the repository. Gradle Nexus name: Publish package to the Maven Central Repository on: release: types: [created] jobs: publish: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Java uses: actions/setup-java@v1 with: java-version: 1.8 - name: Grant execute permission for gradlew run: chmod +x gradlew - name: Version release run: echo Releasing verion ${{ github.event.release.tag_name }} - name: Publish package run: ./gradlew publish env: RELEASE_TAG: ${{ github.event.release.tag_name }} NEXUS_USERNAME: ${{ secrets.NEXUS_USERNAME }} NEXUS_PASSWORD: ${{ secrets.NEXUS_PASSWORD }} SIGNING_KEY_ID: ${{ secrets.SIGNING_KEY_ID }} SIGNING_KEY: ${{ secrets.SIGNING_KEY }} SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }} Build test and publish to Cocoapods project written in Swift At first, the dependencies are restored. Afterward, the project is built, and the Action runs tests. In the end, the package is pushed to the Cocoapods repository using the command. Cocoapods pod trunk push on: release: types: [published] name: publish-to-cocoapods jobs: publish-to-cocoapods: name: publish-to-cocoapods runs-on: macOS-latest strategy: matrix: destination: ['platform=iOS Simulator,OS=12.2,name=iPhone 11 ']
    steps:
      - name: Checkout
        uses: actions/checkout@master
      - name: Build and test
        run: |
          gem install cocoapods
          pod repo update
          pod install --project-directory=Example
          set -o pipefail && xcodebuild test -enableCodeCoverage YES -workspace Example/KenticoKontentDelivery.xcworkspace -scheme KenticoKontentDelivery-Example -sdk iphonesimulator -destination ' name=iPhone 11 ' ONLY_ACTIVE_ARCH=NO | xcpretty
      - name: Publish Cocoapod
        run: pod trunk push
        env:
          COCOAPODS_TRUNK_TOKEN: $ {{ secrets.COCOAPODS_TRUNK_TOKEN }} Bonus: GitHub Actions not only for CI/CD automation Not only can GitHub Actions be used for automating your build, running tests, and release pipelines but you can also leverage them for scheduling automatic tasks, such as web scraping or automatic update routines. This last bonus action runs the Python script at a specific time. The Python script does some automation—in this case, it scrapes the HTML page and makes data readable for machine processing. The output of the script is then committed and pushed to the specified GIT repository. name: Python application on: push: branches: [ master ] pull_request: branches: [ master ] schedule: - cron: '0 0 * * *' jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Python 3.8 uses: actions/setup-python@v1 with: python-version: 3.8 - name: Install dependencies run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt - name: Lint with flake8 run: |
        pip install flake8
        # stop the build if there are Python syntax errors or undefined names
        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - name: Run script run: |
        python stocks.py - name: Deploy page run: |
        git config --local user.email "action@github.com"
        git config --local user.name "GitHub Action"
        git add docs/index.html -f
        git commit -m "Update docs/index.html" -a
        git push "https://makma:$ @github.com/makma/stocks-movement.git" HEAD:master --follow-tags {{ secrets.GITHUB_PERSONAL_TOKEN }} Debrief I believe GitHub Actions can be utilized for many different scenarios. You can find the majority of the example actions above in real-world use—they were based on and taken over from open-source . Feel free to take a look, get inspired, or maybe improve them ;). Didn’t you find your use case in the examples above, or did I not include your favorite GitHub Actions feature? Let me know on or . I’ll be happy to discuss your use case and update the article. Kentico Kontent’s GitHub Twitter Discord

With GitHub Actions, you don’t have to do boring tasks manually ever again

On May 25, 1961, the then President of the United States, John F. Kennedy, set a national goal: perform a crewed lunar landing and return to Earth. After several historic attempts, his goal was achieved on July 20, 1969, when Apollo 11 commander Neil Armstrong stepped off the Lunar Module’s ladder and onto the Moon’s surface. It took 8 years of relentless effort, sacrifice, persistence and finance to land a man safely on the Moon. While there’s no comparison between the effort behind a rocket and a , pictures like the following are quite common: startup And when I look back at the years gone by, it all makes sense. Here’s a thing(or two) about 2018: “When you make a mistake, there are only three things you should ever do about it: admit it, learn from it, and don’t repeat it.” 2018: The Year of Reckoning Truth be told, our entry into 2018 was nothing short of a bumpy ride from the downfall in 2017, and every day, we were battling relentlessly to put our ideas into execution as fast as we could. A lot of them tanked, but we finally pulled one off in early Q1 and that gave rise to a content platform, now ranked among the web properties in the United States. To put things in perspective, here are a couple more statistics: top 350 Served over in a month — that’s almost 5 times the US population. 1.5B ads Reached more than , averaging more than on the platform, every month. 15M readers 200M pageviews Partnered with leading publications like and numerous more for syndicating our content. CNN, BBC, Yahoo News, Fox, Apart from our media division, after months of internal R&D, we also launched a breakthrough advertising product in early Q3, based entirely on video. As of today, it is used by leading publications across the world and contributes tremendously to their advertising ecosystem. Following are some statistics around it as well: Served over in a month, worldwide. 1B video plays Transferred more than of data across all our streaming servers in less than a month. 1.5 petabytes Garnered a direct reach of more than a month. 500M unique users Overall, we managed to recover from the severe hit in 2017, and clocked an annual revenue in low XX million USD. None of the above was an overnight play — it took months of toil, sleepless nights, and innumerable cups of coffee to make it happen. And when it finally did, we were already too busy to take notice. And we still are, raging to push things forward, and scale to 10x of where we are currently — all in 2019. And there’s just one mantra: Do. Or do not. There is no try. We’re ready for and are excited for 2019 with renewed energy, enthusiasm and valour. takeoff We at grew from a team of less than 10 in late 2017 to over 35 in 2018. It took months to find the right fit, and even today, we are on the lookout for talented, committed folks to join the fray and push things forward. The foremost competitive advantage in a startup is speed. Everything else is secondary. And speed is inversely proportional to time. That’s why the one thing we learnt to value most is, in fact, time. Zero1 Inc We’re more of an army — and we seek troopers, people who can give in what it takes to achieve the impossible in the shortest amount of time. People who can challenge the status quo, and don’t take No for an answer. People in fields as diverse as tech, HR, sales, digital marketing, data analysis and Ad operations. Get in touch with us at: hr@z1.co and tell us your story — we might see a synergy and contact you right away.

Stories, News & Mentions about ZERO10

Zero10’s Stories on HackerNoon