Hi everyone, welcome to my course study on Jira software. In this course, you will learn everything about Jira software and I will explain to you each and everything about Jira software from a user perspective and from an admin perspective as well. So, before going forward, I would like to tell you this article is for people who are brand new to Jira. Jira is a very comprehensive tool with a lot of customizable capabilities and I would like to share one secret about how personally we use Jira, we use Jira to track our day-to-day activities and we love to use it to track our activities. For this article, I have certain agenda.

What is JIRA?

So, we move forward to know more about what is Jira? So, Jira is project management, issue-tracking, and bug-tracking tool. For agile software and business teams. It is made by a company and the company name is Atlassian. It is an Australian company but now they have different offices in many countries. Actually, the name “JIRA” is inherited from the Japanese word “Go Jira” which means “Godzilla”.   

Why should we use JIRA?

There are lots of software available in the market which are very similar to Jira then why should we use Jira? Why do the people in most of the organizations prefer to go with a Jira? So, the reason is it has everything that you need to manage projects and teams and is fully customizable to your needs, you can customize your workflow, add your custom issues types, you can add your fields, and design your issue operations screen as per your team requirements and countless adds-on to further enhance the functionality. Let me tell you about the marketplace of Jira where you can find various apps which are used to enhance the functionality of Jira. Let me tell you about the official website of Atlassian www.atlassian.com and you will click on the product tab, you will see on the right-hand side, you will have an option of the marketplace so, you will click on that and you will find multiple apps already available. You can filter as per the Atlassian products, if you will click on Jira then you will see lots of apps are available like tempo timesheet, automation for Jira, and many more so you can use any app according to your requirements so let’s move forward for another one. Features Jira has lots of features that make your life easier.    

What are the JIRA products?

The other one is what are the Jira products? Many peoples are not aware of like Jira is a family of products, built to help all types of teams track their work there are four products built on Jira platforms:

• Jira core
• Jira software
• Jira service Desk
• Jira Ops

I will tell you one by one what is the meaning and what are the features for these products so, let’s start with the first one Jira core, what is Jira core? It allows you to track issues using a customizable workflow which basically determines how issues can flow from start to completion and what are the other steps along with. This basic functionality that would you get with Jira core is the base bare minimum Jira tool that you can use for simple business-related products and task management. Let’s move forward to the next one and which is Jira software with Jira software which you will be using in this complete course. You have extra agile functionality where you can track software projects with agile methodology. In other words, Jira software includes both Jira core plus agile methodology. Now, what is the Jira service desk? It is a service desk that is used for support projects using the Jira service desk you can give a better experience to your customers they can easily ask for help and your agents can respond to them in a better way. The other one is Jira Ops, which is an incident management tool. It is used to centralize alerts and notify the right people at the right time so, these are the four products that come under the Jira platforms.  

Which agile methodology is used in JIRA?

Most of the people who start to learn Jira, who use to learn Jira has this question in their mind which agile methodology is used in Jira? So, I will tell you Jira software is an agile project management tool that supports any agile methodology, be it Scrum, Kanban, or your own unique flavor. You can use Scrum, Kanban, mixed methodologies, and agile scale up to your requirement but this software fit your framework scrum, Kanban, or your unique another one so, in this course you will focus on scrum and a little bit about Kanban as well because I saw most of the organization uses scrum, Kanban as well. I wish that you will get more core fundamentals about Jira methodology and it will more guide you in the future points of view.

Related videos:

Hello everyone, welcome to the next level of programming. In today articles, we are going to give you lessons on various topics as how you add your GitHub project to eclipse and how can we create a GitHub repository how do we clone the repository in eclipse how can we add the eclipse project to GitHub, and then how we can finally commit push and pull. So, let’s start.  

How to create a GitHub repository?

Step number one is.

Step 1: Create a GitHub account with a sign in

You will have to create an account on GitHub so, you will go to your browser and you will go to GitHub so, you will say GitHub and the very first website you will get that and github.com so, you will go there and you will create your account so, you will add your you will pick a username you can give some email id or valid email id and then choose a password and then you will sign up for GitHub you will get a link in your email to verify your account and then you will verify and then finally you will sign in so you already will have an account so you will just sign in to your account and now there you will get that page and there you will see that start a project a button so, this is the step no. two

Step 2: Start a project = create a repository

Then you will have to start a new project so you will go and start a new a project and you can give any name so you will give that is a test project and then you will give some description which will optional and make it public and then you will create the repository so click on create a repository and there you will have that new repository and you will have a link of that repository there so now you will go back.

How to clone the repository in eclipse?

Now, what will you do is step number three is

Step 3: Start eclipse

You will start your eclipse so you will go to your eclipse now so that will be an eclipse and you will have to go to git repository perspective so will you see this open perspective button there you will click on that open perspective and then you from there you will have to select git repository also you will start typing git repository there and you will get this perspective and git repository so select git repositories and there you will get that git repositories window and there you will have buttons so that will be an add an existing local git repository that button will be to clone of your git repository and the clone to this view and then you will have to create you git repository so in your case you will already have created your git repository so you will click on that clone or git repository and add that grown to that view so you will click there and before you will add so step no. four will be

Step 4: Go to perspective >> git repositories and click on add git repository

Now, you will add the URL there so you will copy that URL from there that just copy it from there and then go back to eclipse and just paste it there it will take all the hosts and repository path itself and then you will give your authentication which will be your user and the password of GitHub account and even if you will not give it will ask you later on so if you will say next there so it will search for the repository and then finally it will have given you that window you will select next again and then it will give you the local directory so you will change that if you want and then you will say finish and you will see that progress there so it will be cloning the repository from the GitHub remote repository and finally you will see that project will have come there so you will have got your repository into your eclipse now the next thing is you will have to create a project in eclipse and add to this repository. I hope, all this will make you more eager to learn about what you can do with GitHub projects and eclipse.

How to add eclipse project to GitHub repository?

So, step no. five is

Step 5: Create a project in eclipse

So, you will create any project so you will say new java project you will also click there file new and then select the java project so there you will give some name you will give the same name as well that will test project and say finish so you will have got your test project there now what you will do is you will do a right click on that project and then you will go to team and then you will select share project and there it will ask you for the repository and now you will see you will have caught that test project repository there and that will be displayed only once you will have added project in the repository or you will have clone the repository so just select that repository and then you will say finish and now this project will be added to that repository and you will see that icon has also been changed now if you will back to your repository on GitHub and you will refresh it you will not find anything any change there as of now the reason is because you do will have not done any commit or you will have not done any push to the repository so as of now that will be that will look like as before so you will see that will be the same view. Let me add the steps so step no. 6 will be

Step 6: Do a right-click on project >> share >> Add to Git repository

And finally you will do some changes or you will do a commit so, you will do a commit first so you will again do a right-click and go to team and now you will see you will have got all these options and that will come only after you will have added the project to the repository so now you will click on commit and now it will have given you all these changes or additions that you will have done you will select all or you will select the ones that you want to commit and drag and drop to the stage changes area so now you will have staged that you will also add some commit message first commit and then you will do commit and then push or you will do commit and push at one go so you will say commit and push and it will give you that dialog boxes you will say next so you will write it down and it will ask you for the username and password and there will be user and password of your GitHub so your username will whatever and you will add your password and now finally it will give you the branch and as of now you will have only master branch so you will say finish and you will see you will give your username and password again and you will also store this username and password so you will not have to give it every time but as of now you will just give it and you will see the progress there and meanwhile that will have done.    

How to commit, push and pull the changes?

Then step no. seven will be

Step 7: commit and push the project to the repository

You will add commit and push the project to the repository and then step 8 will be whenever you will make any change

Step 8: commit and push every change to the repository

So as of now that will have done and now if you will go to your repository and refresh it you will see that would now show you your project and as well as your commit so you will refresh and see and definitely you will see that you will have got your test project there if you will click there you will get that details inside that test project and you will see all these details and also you will see the first commit there which will have happened just two minutes ago and now if you will make any changes for example: you will create a new class there so you will create a new test class there and now and anytime & every time you will make any change you will just go to do a right click on the project go to team you will say commit and you will see that will show you the changes and you will then add a message added class test dot java and then commit and push so that will commit you will add your username and password and that would commit the changes again to the remote repository and if you will go back to your remote repository and refresh that again you will now see you will have got that change added class test java and if you will go inside the source you will have your test dot java class there so this is how you will make sure all your changes will be committed to your remote repository and this is how you will do a pull push and commit so you will also for example: go to team and then you will have all these options there you will do a pull you will pull or push from a particular branch and then you will commit in all these changes this is how you will add your GitHub project to eclipse and then will push and pull so, I hope, all these lessons will be beneficial for you. These fundamental steps will give you the correct path in the journey of adding the GitHub project to eclipse.

Related video:

Hello everyone, welcome to the learning path of programming. Today, in this article we are going to discuss various topics like how can we create a GitHub repository how do we clone the repository in eclipse and then we will see how do we add the eclipse project to your GitHub repository and then finally we will see how do we commit push and pull the changes inside the repository so, let us start.

How to create a GitHub repository?

So, Step number one is.

Step 1: Create a GitHub account with a sign in

You will have to create an account on GitHub so, you will go to your browser and you will go to GitHub so, you will say GitHub and the very first website you will get that and github.com so, you will go there and you will create your account so, you will add your you will pick a username you can give some email id or valid email id and then choose a password and then you will sign up for GitHub you will get a link in your email to verify your account and then you will verify and then finally you will sign in so you already will have an account so you will just sign in to your account and now there you will get that page and there you will see that start a project a button so, this is the step no. two

Step 2: Start a project = create a repository

Then you will have to start a new project so you will go and start a new a project and you can give any name so you will give that is a test project and then you will give some description which will optional and make it public and then you will create the repository so click on create a repository and there you will have that new repository and you will have a link of that repository there so now you will go back.

How to clone the repository in eclipse?

Now, what will you do is step number three is

Step 3: Start eclipse

You will start your eclipse so you will go to your eclipse now so that will be an eclipse and you will have to go to git repository perspective so will you see this open perspective button there if you will click there on open perspective and then you from there you will have to select git repository also you will start typing git repository there and you will get this perspective and git repository so select git repositories and there you will get that git repositories window and there you will have buttons so that will be an add an existing local git repository that button will be to clone your git repository and the clone to this view and then you will have to create you git repository so in your case you will already have created your git repository so you will click on that clone or git repository and add that grown to that view so you will click there and before you will add so step no. four will be

Step 4: Go to perspective >> git repositories and click on add git repository

Now, you will add the URL there so you will copy that URL from there that just copy it from there and then go back to eclipse and just paste it there it will take all the hosts and repository path itself and then you will give your authentication which will be your user and the password of GitHub account and even if you will not give it will ask you later on so if you will say next there so it will search for the repository and then finally it will have given you that window you will select next again and then it will give you the local directory so you will change that if you want and then you will say finish and you will see that progress there so it will be cloning the repository from the GitHub remote repository and finally you will see that project will have come there so you will have got your repository into your eclipse now the next thing is you will have to create a project in eclipse and add to this repository. I hope, all this will make you more eager to learn about what you can do with GitHub projects and eclipse.

Related video:

Hello everyone, welcome to the wonderful part of the programming session on that where we had left the most important sections of GitLab CI/CD. Now, we are going to start from where we had left on the accounts of the creation of the .gitlab-ci.yml file or how to run the CI/CD pipeline. If you want to learn from scratch so, you may visit previously happened articles for proper assistance. So, let’s start with the rest part of the topic that describes most parts of the GitLab CI/CD.

Create .gitlab-ci.yml file

Step 1: Add .gitlab –ci.yml in the root folder of your projects/repo

I’m starting from where I had left the rest part of creating the GitLab YML file. So, after saving your project, you will go to your desktop and you will press command shift and dot on your keyword because this will be your hidden file you will copy that and move it to your projects folders you will have created a project and in the project folder, you had created a folder called GitLab in GitLab you had your first project. The same thing you can do in windows so the steps will remain the same you can just copy it in your projects folder wherever it is so it will be there your first projects you can just copy that file there so, you can actually copy that file there. Now, this was step number one and you will also copy the contents of that file so, you will see it you can also copy that in notes that will be the file you will have created this was step no. one and now, the step no. two is

Step 2: commit and push file to GitLab repository  

So, now because you have added that in your project you just need to commit and push in your gitlab repository you will have already know the commands for committing and pushing so, open your terminal there if you will on windows you can open git bash or the command line and first you will change the location to your project so, you will see say CD and go to your project folder and there if you say git status you will see you are getting that file will not yet added so you will say git add dot and all these comments you have learnt and then you will say git commit so if you again say git status you would see it in green so you will see now it will be added and then now you will say git commit –m “ added .gitlab-ci.yml file  and now you will push say git push –you origin/ master so you have you will give the URL instead of origin so there you will add the URL of your repository you will go to gitlab and go to your project and there you will click on clone and copy this HTTP link and provided there and hit enter if you will not have added your credentials there and you believe you have done it on windows you wil go to your command line and go to the location of your project there and now you will say git status and your file will be having there. You will say git add and git status again you will now say git commit –m “added .gitlab-ci .yml” and you would say git push –u origin master or you will say git push –u and give the link there of your first project they would push the changes if you go and check your project now you would have your GitLab CI ml file there so you will see now it will be there so you had pushed the changes.

Run CI/CD pipeline

 Now, the next thing is step no. three will be

Step 3: Create GitLab runner for the projects

So, if you go to your project you will go to your project go to settings and there you would go to CI/CD and in the runner, if you expand you will see you will have this runner created earlier so this runner will have already created so, this we have already done step no. three. Step no. four will also make sure that the runner that you are using has your tag that you will have given in your ml file so you will have your tag there CI that you will have given in your ml file now step four will be

Step 4: Start the runner  

Now, you will start the runner so, you will also start from your Mac or windows anywhere you will have learned this how to start so you will just say there brew service says start GitLab you don’t know if you will go to GitLab runner so, there is the documentation for GitLab runner so, you are on windows you will see there you will have for Mac for windows all these things you will have. And you can use this so if you are on windows you can just run this GitLab runner .exe start so there that will have already started so that is fine so you can start and stop but that is fine it will be started so once you can start that or now then step no. five will be

Step 5: Make any change in the project >> commit >> push

 So, basically what you will have done is you have added this CI job or you had added this GitLab CI YML file in your project that will now check for any commits and push in the project whenever you do any commits it will if you will have runner running if you will have GitLab runner running having the same tags like what you will have given in the file. For example: you will have given CI there then it will start the job whatever you will have given in the CI file in the gitlab CI file so now you will make some change there you will go there to your project and you will just some file there or you will not add a folder you will just add a file you will say new file you will say that is test 1.txt that will be test file and you will save and close it if you will go to your command line if you will say git status that will be added so you will say git add you can say test1.txt or you can say dot for everything and you will say git commit –m “added test1 .txt” and now you will have to push so you will say git push –u and the URL and master and once you do this when you will go to your projects there and you will go to CI/CD and once you will go there you will see this job’s getting triggered in the job section and you will push that if you will go there and refresh or you will go to the jobs you will see it is now there it will say pending so this is that will run now if you will go inside you will see that is a demo job one that you will have created in your gitlab CI file if you will click there you will see this is running and that will be now passed and you will see it is running hello World so it will say echo hello world and it will be printing hello world and you will see the locks there you will scroll from there that was a very small job so you don’t have lot of logs you can erase the job log you can see the complete raw log all that you can do so now on every commit and push in project it will check if you will have gitlab runner running and you will have this CI file the gitlab CI file it will run the file and whatever jobs you will have added whatever scripts you will have added it will run accordingly so from now on words whenever you will make changes it will triggers that jobs whatever you will have configured in your file so this is in very basic way how you can get started  with gitlab CI/CD of course there are lot of complex yml file set you can create as per your needsif you will go to the gitlab documentation you will see examples and samples of a lot of yml file and you can check them and see how you can use them so, this was the beginning of gitlab CI/CD at a very basic level so, I hope all this will very useful for you please do a hands-on and try some more jobs running some more jobs and gitlab CI/CD.                

Hello everyone, you know the different phases of programming and about its evaluation on that, it is performing their task. So, we are going to learn about Gitlab CI/CD from very basic & scratch and if you don’t have primer knowledge on the above topic so, don’t worry, we will go up step by step. And in this lesson, we will engage with various topics like what is Gitlab CI/CD? We will create a .gitlab-ci.yml file, this is a file where we add our jobs and create a pipeline and I will show you how to do that then we will run CI/CD pipeline in Gitlab so, this is going to be very easy and interesting.

What is Gitlab CI/CD?

Let us learn about what is Gitlab CI/CD? So, you will go to Google & search for continuous integration and delivery. You will go to images and select one image there. You will see there, you will have continuous integration then CI stands for continuous integration so, the continuous delivery is CD and again, we will call continuous deployment is CD so, this is what we call CI/CD. And there, if you will look at continuous integration. There will be a process where you will have these three jobs and processes, chained and linked with each other. Why is it will be linked? I mean, if the first dev process or dev job runs and passes. And it will trigger the next job that is in the test job application test. If the passes it will trigger then the next job that is an integration test and you will have our continuous integration pipeline completed so this is what is called as CI or continuous integration and if this all these jobs in this cycle are chained with each other and our automated triggered we call it as a continuous integration system now if you also add an acceptance test job or acceptance test process which is also automated and linked this becomes a continuous delivery because after this step our application or our product will be ready for delivery so this becomes continuous delivery and if we also add our deployment job or a deployment process that will reply to the production and all these jobs are automated and chained and can be automatically triggered then this becomes a continuous deployment pipeline so this is what we call as continuous integration and continuous delivery and continuous deployment. Now, in GitLab as well we have this corners integration delivery and deployment, and here this GitLab CI is an open-source CI service or a continuous integration service included with GitLab and by default, this is integrated with every in your GitLab since version 8.0 so, if you are using version 8.0 or above GitLab then in all your projects by default you will have GitLab CI integrated and enabled by default and to go to the settings and to configure GitLab CI you should be a maintainer or our owner or an admin on your project so, you go to your GitLab account if you just go to your Gitlab you will sign in so, you can see there your projects and if you see the projects there you will be maintainer on one projects and owner on the other projects so, you can configure GitLab CI/CD so, this is what GitLab CI/CD is now.

Create .gitlab-ci.yml file

Actually, create a GitLab CI/CD pipeline, you will have to add a file called .gitlab –ci.yml so, yml files or ml is a format of writing text files, and like you have JSON and XML. Ml is also a format and I will show you that how to create it and you have to create this file in the root folder of your project or your repository so, whatever the root folder is and you will be creating this file in the main folder or the root folder of your project. Now, before we start creating this file so, this is used to configure our pipelines and in every project, you will be having, you will be adding this file where you can add the details and it will define the structure and order of the pipeline and once you create it you will know exactly what you mean do not worry if there is there are some things that you are not getting once you create the file and run it you will know exactly what it means? So, you will create a file now if you are on Mac, you can use any text editors like you have text editors on Mac then you have text wrangler anything will work if you are on windows, you can again use notepad or notepad ++ or in fact, you can use any editor but you have to make sure the syntax is correct and I will show you how you can check the syntax so, you will open your window with notepad++. You will open a new file and on your mac, you will open your text wrangler file so that you can create it there so to create a file you will just give some name of the job you will say that is demo job one. So, you will say demo job one any name you can give there and give a colon go to the next line and you will give five spaces so, you can give any number of spaces but you will have to be consistent with that so now you will say tags and there give a colon again go the next line give two spaces and you will give a hyphen and spaces and I can give any tag here now tags are important because in your gitlab you will be having the gitlab runners and they have some tags and the text should match only then the gitlab runner will run this particular file so if you go to my project on gitlab and there if you go to settings and go to CI/CD and you have runners there you will click on expand and you can see you had created this runner earlier and you had given this these tags there CI and SSS so you should be having one of these tags so that the runner can pick up this file and run it so, you will say CI there and you will go again to next line now again you will give there script and this is in line with tags again go to next line two spaces – and there you can write any command or script you want to run so, you will say hello echo hello world so they should run this command in this job this is a very simple file where you are running that script echo hello world so they should print hello world on the console and now you can also do the same thing on your windows on the notepad so you can create it like this and now you will have to make sure the syntax is correct and for that you can copy the contents and you can just go to google and search for any ml file validator utility or application and you will see that you have yam lint, yaml validator online this all you will go to yaml lint and paste your contents of the ml file and there you have to go button you will click there go and check and yes everything is fine it will says it is a valid YAML so that is fine you will now just save this so you will save this file and you have to make sure the name there should be .gitlab –ci.yml as of now you will save on desktop but you will move it to your project folder so, you will say as it is. I hope this will more authenticate your performances and give you a hike in the sections of Gitlab CI/CD.

Related video:

Hello friends, today, we are going to teach you about Gitlab runner. On that how can you install, register, start Gitlab runner and we will do this on the Windows operating system (Windows OS). So, if you want to learn Gitlab runner then we will start from very basic it means from scratch and we will go up step by step.

What is Gitlab runner?

Before, I write down the steps to all procedure that happens in Gitlab runner. Let us see, what is Gitlab runner? So, in the very simple word if you talk about Gitlab CI. It is an open-source continuous integration service included with Gitlab. So, this service by default is included with Gitlab. It is used to run jobs & send results back to Gitlab.    

How to install Gitlab runner?

So, you will go to your Google and search for Gitlab runner. There will be a documentation page and you will go there. You will see all the documentation about Gitlab runner there so, it is written in a go programming language. And you may see all the features will be there, it will allow multiple jobs concurrently & compatibility. Then you will have a section for installing Gitlab runner and have an installed link. If you will see that there will be a link for Gitlab runner from there, you may install it. And you have lots of binaries over there so, you will go on windows. You will go to your window system and go to the same link. So, you will have the instructions for installation. You will create a folder in the name Gitlab-runner and you will choose from your C drive option, create a folder in the name of that. And the next step, you will have to download the binary for your operating system. You will go to your computer and this pc option and do a right-click, you will go to properties option. And you can see all details about your operating system, the bit size & everything. So, you will choose the bit size and download the Gitlab runner .exe. If you will go to your download folder then it will be there. You will copy that from there & move it to the folder Gitlab runner that will have been created. You will paste in that and rename it. If you will go to the documentation page so, there will be mentioned to take the rename the binary to Gitlab runner. Then you will have to run an elevated command prompt for this. Now, what does it mean? It means that you can run your command line with admin rights. And you can also use Git bash there, you will just move to your command line and from there, you will choose run as administrator option. From there, you will go to the location of that folder. Suppose, you will have in other drives like e drive then first, you will have to change the drive-by saying or writing e: and enter then you can go to the location. Also, the shortcut is you can go to the address bar of your folder and you will say cmd, press enter. Then it will open in the same folder, this is the shortcut so, you can do it. In your folder, you will have to run the command GitLab runner .exe install. So, you will run this command in administrator then you will see that it is done. If you will say GitLab runner –version then you will get all details there. So, these are the commands:-

Gitlab runner .exe install

Gitlab runner –version

To check, if your GitLab runner is installed so, you can run the command gitlab runner –version. Then you can also start using this command GitLab runner .exe start.

How to register Gitlab runner?

Now, you need to register your GitLab runner. If you will go to the GitLab documentation page then you will have the link to register GitLab runner. If you will scroll down, you will see that multiple operating systems and documentation for that. Further, you will scroll down, you will have windows. There will be steps that you can use for windows. So, you will first run GitLab runner .exe stop to stop the runner and for registration, you will have to run the command GitLab runner .exe register then you will do the registration process. So, it will ask for GitLab coordinator-ci URL and after entering the URL. Then it will ask for a GitLab-ci token so, the token you will get from your projects. You will log in to your GitLab account and will go to your projects, you can also go to your projects from the top bar. Then in your projects, you will go to settings. Under settings, you will go to CI/CD and there you will find sections of the runner. You will see sections for setup runner manually, there you will also see those steps you will have already done and the token will be there. After providing the token, you will have to provide some description like my-runner1 and anything you can say here. And it will also ask for GitLab-ci tags then you can add like ssh, ci, etc. If you will enter then it will show register runner …..Succeeded and everything will be done. Then it will ask to enter the executor like ssh, Kubernetes, custom, virtual box, Docker machine, etc. Then you will put shell and press enter so, it will show the runner registered successfully. So, you will start the runner using the command like gitLab runner .exe start  

How to start Gitlab runner?

Now, you will have to check. To start the Gitlab runner, the gitLab runner .exe start is the command to check. Then you will have to check if the runner is started and the next step will be to check runner is started in the project. The same thing, you will have to do for this. You will go to your projects then settings and after CI/CD. Again, you will go to runner and scroll down. If you will scroll down, you would see the project is activated under the runner. You will also see the name that you had given to that. Now, this runner will be activated and it can run the jobs. All this, you will have learned how to run jobs, use tags, and Gitlab ci. I hope, this data will be very helpful for you.

Related Video:

Hello guys, welcome to the digital world of programming, today, you are going to learn about how to upload projects in GitHub and about local files which are in your system, we are going to teach you how can you upload that files to your GitHub repository. If you have an idea about commit, forks, pull request, merge, and branch. And how can you do contributions to projects? That’s ok, otherwise, you’re a beginner. So, it will be more beneficial to you than a pro user.

Creating a new GitHub repository

What you will do first, first you will make a repository. You have made a repository from the name of the programmer and after doing a public option, you have uploaded that. When the repository will have made, you will see that, if you will click on that, there will be not any code. So, you will copy that link from there & move it to the files where you have put some codes and wants to upload it.

How can you upload projects on GitHub?

If you want to upload some files related to code that you have kept in your eclipse then go to the team option and share that project. After sharing is done, you will go to the team option by doing one right-click and you will select the commit option. When you will do commit then there will come all your files which be selected by you. You will add that files in stage changes and after this, you can write some commands like programmer first commit. After doing so, you will do commit & push and fill up all the push branch matters by adding a remote name, URL links, host, id, and password for authentication, after that you will do checking by clicking on the preview option. You will see, there will be happening connections in the eclipse. After this, you will do push and close that and you will see your GitHub files by doing a refresh in that your programmer file will have uploaded along with all the files which are committed by you.

Push code to GitHub

You will see there, all the .txt files which are uploaded by you. If you will open all the .txt files to fetching in eclipse then you would be a wonder to see that all programs and commit will be available there. Whether you will check, there will be similar programs in both GitHub and eclipse. So this way, you can directly upload your files from the eclipse to the GitHub programmer repository. You have learnt many more things about GitHub. So, stay tuned for more information.

Related video:

Google Cloud Dataproc Integrates Apache Spark with Kubernetes

Google Cloud Dataproc released an alpha preview of Apache Spark running on Kubernetes in September 2019, positioning it as the first managed cloud service from a major provider to offer this integration. While other vendors — including Databricks (founded by the creators of Apache Spark) and D2iQ (formerly Mesosphere) — support Spark on Kubernetes, Dataproc’s move signals that the major cloud platforms are beginning to treat Kubernetes as a first-class resource orchestrator for data-intensive workloads, not just stateless microservices.

Why Run Apache Spark on Kubernetes Instead of Hadoop YARN?

Historically, Apache Spark has run on top of Hadoop YARN, the resource manager and job scheduler that ships with the Hadoop ecosystem. Kubernetes, by contrast, was designed for containerized, often stateless applications. So why shift?

There are several operational benefits to using Kubernetes as the resource orchestration layer under Spark:

• Portability: Containers run consistently across on-premises, hybrid, and multi-cloud environments, making it easier to move Spark workloads without re-platforming.
• Configuration consistency: Container images capture dependencies and runtime configuration, reducing environment drift between development, staging, and production.
• Automated provisioning and scaling: Kubernetes-native horizontal scaling and Helm charts enable dynamic resource allocation without manual cluster resizing.
• Resource efficiency: Containers typically pack more workloads onto a given host than virtual machines, reducing infrastructure costs for bursty analytical jobs.

Doug Henschen, an analyst at Constellation Research, framed the business case clearly: “Analytical workloads, in particular, benefit from the ability to add rapidly scalable cloud capacity for spiky peak workloads, whereas companies might want to run routine, predictable workloads in a virtual private cloud.”

Where Hadoop’s Container Story Falls Short

Apache Spark added a native Kubernetes scheduler in version 2.3, and Apache Hadoop introduced native container support in Hadoop 3.0.3 — both released in May 2018. However, Hadoop’s container integration remains tightly coupled to HDFS and is widely regarded as complex to operate in practice.

James Malone, product manager for Cloud Dataproc at Google, offered a candid assessment: “People have gotten Docker containers running on Hadoop clusters using YARN, but Hadoop 3’s container support is probably about four years too late. It also doesn’t really solve the problems customers are trying to solve — customers don’t care about managing Hive or Pig, and want to use Kubernetes in hybrid clouds.”

Google’s strategy with Dataproc is therefore to bypass YARN as the orchestration layer and route Spark jobs directly through Kubernetes, using GKE (Google Kubernetes Engine) as the underlying cluster infrastructure.

What the Alpha Integration Actually Covers

At alpha release, the Dataproc Spark-on-Kubernetes integration was split across several parallel workstreams, according to Malone:

• Dataproc cluster updates: Enabling Cloud Dataproc itself to provision and manage Kubernetes clusters rather than traditional YARN-based Hadoop clusters.
• Upstream Spark Kubernetes operator contributions: The Spark Kubernetes operator — which defines how Spark applications are submitted and managed as Kubernetes custom resources — was still in the experimental stage within Spark Core at the time of release.
• Performance add-ons: Features such as external shuffle service support, which enables dynamic resource allocation by allowing shuffle data to persist beyond the lifetime of individual executor pods, were not yet fully integrated.

Google also signalled plans to extend Dataproc’s Kubernetes support beyond Spark to other Apache data analytics frameworks, including Flink (stream processing), Druid (low-latency queries), and Presto (distributed SQL).

Known Technical Friction Points

Python vs. Scala Executor Experience

Michael Bishop, co-founder and board member at Alpha Vertex — a fintech startup running machine learning workloads on a multi-cloud Kubernetes infrastructure — highlighted one practical rough edge: the Python experience in Spark on Kubernetes has historically lagged behind Scala.

“The Python experience of Spark in Kubernetes has always lagged the Scala experience, mostly because deploying a compiled artifact in Scala is just easier logistically than pulling in dependencies for Python jobs,” Bishop said. “This is getting better and better, though.”

The core issue is that Scala Spark jobs compile to a JAR file that the executor can load predictably, whereas PySpark jobs require coordinating Python environments and dependency resolution across distributed executor pods — a challenge that container image layering partially addresses but does not eliminate.

Scheduler Impedance Between Spark and Kubernetes

A deeper architectural tension exists between how Spark and Kubernetes each think about scheduling. Spark’s scheduler is data-locality-aware: it tries to schedule tasks on the nodes where the data they need already resides, minimising network transfer. Kubernetes, by contrast, is primarily concerned with pod resource requirements and node capacity — not data locality.

Bishop described this as a fundamental impedance mismatch: “Spark is intimately aware of ‘where’ is for [nodes], while Kubernetes doesn’t really care beyond knowing a pod needs a particular volume mounted.”

This gap matters most when Spark jobs depend on HDFS or other distributed storage that benefits from data-local reads. In cloud-native deployments using object storage (such as Google Cloud Storage or Amazon S3), data locality is less critical because the storage layer is already remote — which is one reason the Kubernetes model fits cloud-native Spark deployments better than it fits on-premises Hadoop clusters.

What Teams Running Spark on Kubernetes Need Today

As of the alpha release, teams wanting to run production Spark workloads on Kubernetes outside of a fully managed service needed to assemble several components independently:

• The upstream Spark Kubernetes scheduler (built into Spark since 2.3, but still maturing).
• A supported Spark distribution, such as that provided by Databricks.
• A Kubernetes cluster, either cloud-managed (GKE, EKS, AKS) or self-hosted.
• For hybrid cloud portability, a distributed storage layer capable of running across clusters — vendors such as Robin Systems and Portworx were among those offering solutions at the time.

Assembling these pieces is possible, but it requires significant operational expertise and lacks the managed-service conveniences — automated upgrades, integrated monitoring, IAM integration — that a platform like Dataproc is designed to provide once the integration matures.

Key Takeaways for DevOps and Platform Engineering Teams

• Kubernetes is becoming a viable resource orchestration layer for Apache Spark, particularly in cloud-native and hybrid cloud environments where object storage replaces HDFS.
• The move from YARN to Kubernetes reduces Hadoop operational overhead but introduces new challenges around scheduler data-locality assumptions and Python dependency management.
• Google Cloud Dataproc’s alpha integration in 2019 represented a significant signal of direction, even if the implementation was incomplete at launch.
• Teams evaluating this architecture should assess whether their Spark jobs are data-locality-sensitive and whether they require external shuffle service support before committing to a Kubernetes-based execution layer.
• Upstream Spark and Kubernetes project maturity, not just managed service features, determines when this stack becomes production-ready.

Why Kubernetes Needed a Formal Security Audit

Kubernetes has grown into the de facto standard for container orchestration, underpinning production workloads at organizations of every size and sector. Yet despite its widespread adoption, the project had never undergone a structured, independent security audit at scale. With backing from the Cloud Native Computing Foundation (CNCF), the Kubernetes project leadership established the Security Audit Working Group to change that.

The scope was significant: roughly 1.5 million lines of code. The group included participants from Google, Red Hat, and Salesforce, as well as the broader security research community, and engaged two specialist firms — Atredis Partners and Trail of Bits — to carry out the technical work.

Audit Goals and Deliverables

The working group recognized from the outset that no single engagement could comprehensively cover a codebase of this size. Rather than attempting exhaustive coverage, the team prioritized work that would raise the baseline for all future security efforts — whether by subsequent auditors, independent researchers, or the Kubernetes development community itself.

The audit produced a defined set of artifacts intended to serve multiple audiences:

• Two Security White Papers — high-level guidance for cluster operators and developers on securing Kubernetes deployments.
• A Threat Model — a structured analysis of attacker goals, trust boundaries, and attack surfaces within Kubernetes.
• A Security Review Report — detailed technical findings produced by Atredis Partners and Trail of Bits.
• A published Request for Proposal (RFP) — documenting the vendor selection process for transparency and to guide future initiatives.

Publishing the RFP and vendor selection criteria was a deliberate choice. The working group wanted the process itself to be repeatable and open, not just the findings.

What the Audit Found: 37 Findings, Five High Severity

The research produced 37 findings spanning a wide range of security control categories. Of these, five were rated high severity. All findings were formally reported to the Kubernetes Product Security Committee and remediation work began immediately following disclosure.

The findings covered a broad spectrum, including:

• Authentication and authorization weaknesses — issues affecting how identities are verified and permissions enforced.
• Pod Security Policy bypass vectors — vulnerabilities allowing circumvention of critical workload isolation controls.
• Cryptography concerns — including support for older, less secure TLS cipher suites.
• Timing attacks — subtle vulnerabilities exploitable through observable timing differences in cryptographic or comparison operations.

Beyond the 37 enumerated findings, the audit generated 241 pages of supporting material, including detailed recommendations, threat models, reference architectures, and prioritized areas for future security research.

No Fundamental Architectural Flaws Found

One of the most important conclusions for operators and security teams evaluating Kubernetes for sensitive workloads: the audit did not uncover fundamental architectural design flaws or critical vulnerabilities that would warrant pausing adoption for high-security or business-critical environments.

This is meaningful context for enterprises conducting their own risk assessments. The findings represent real issues that warranted fixing, but Kubernetes’s core architecture was not found to be structurally unsound from a security perspective. Kubernetes security was maturing — and this audit formalized and accelerated that process.

How the Audit Was Structured to Enable Future Work

A recurring theme in the working group’s approach was building infrastructure for future audits. By documenting the RFP process, publishing threat models, and releasing findings openly, the group created reusable artifacts that lower the cost and increase the quality of subsequent security reviews.

This mirrors best practices from mature software security programs in other ecosystems, where the first audit is often as much about establishing process as it is about finding bugs. Kubernetes, with its rapid development pace and large contributor base, particularly benefits from having a documented, repeatable security review process.

What This Means for Kubernetes Operators

For teams running Kubernetes in production, the audit offers several practical takeaways:

• Review the white papers — they translate technical audit findings into operational guidance for hardening clusters.
• Audit your TLS configuration — ensure your clusters are not negotiating deprecated or weak cipher suites.
• Evaluate your Pod Security Policy (or successor) implementation — the bypass findings underscore that PSP requires careful, correct configuration to be effective. Note that Pod Security Policy has since been deprecated in favor of Pod Security Admission and third-party policy engines.
• Track the Kubernetes Product Security Committee — future vulnerabilities will be disclosed and remediated through this channel.
• Use the threat model — even if you do not have resources for a full internal audit, the published threat model provides a structured framework for evaluating your own exposure.

A Foundation for Ongoing Security Research

The 2019 audit was explicitly framed as the first of many. The Security Audit Working Group committed to continuing its involvement with the Kubernetes project, using the knowledge gained to guide ongoing security improvements across the project, its distributions, and its user community.

For the open-source security community, this audit set a precedent: large, complex infrastructure projects can and should undergo rigorous, transparent, and publicly disclosed security reviews. The CNCF’s willingness to fund this work, and the working group’s commitment to publishing everything openly, raises the bar for the entire cloud-native ecosystem.

The full Security Review report, Threat Model, and White Papers were published by the Kubernetes Security Audit Working Group. Researchers from Atredis Partners and Trail of Bits are individually credited in each document.

Background: Why the CNCF Commissioned a Kubernetes Security Audit

On 6 August 2019, the Cloud Native Computing Foundation (CNCF) published a blog post detailing the results of a formal, third-party security audit of Kubernetes — the foundation’s flagship project and the most widely adopted open-source container orchestration platform. The CNCF had previously piloted its security audit programme with three smaller projects: CoreDNS, Envoy, and Prometheus. Following the success of that pilot, the programme was extended to Kubernetes itself.

Making the full audit findings publicly available — rather than sharing them only with maintainers — was a significant decision. It reflects a commitment to transparency and sets a concrete example for how large open-source communities can handle security at scale.

What the Audit Covered: Scope and Methodology

The auditors examined Kubernetes across five security control families:

• Networking — traffic flows, network policy enforcement, and exposure of internal APIs
• Cryptography — cipher suite choices, certificate management, and transport-layer security
• Authentication and Authorization — RBAC configuration, admission control, and identity verification
• Secrets Management — how sensitive data such as credentials and tokens is stored and accessed
• Multi-tenancy Isolation — namespace boundaries, workload separation, and privilege escalation paths

Given the sheer size and complexity of the Kubernetes codebase, the audit deliberately favoured breadth over depth. The goal was to produce a holistic security health assessment across all five areas, rather than exhaustively audit a single subsystem. Short-term and long-term remediation goals were recommended for each control category.

The Five High-Severity Findings

The audit identified five findings rated as high severity. Each touches a fundamental security concern:

• Access control bypass of PodSecurityPolicy — An attacker or misconfigured workload could circumvent the policies intended to restrict pod behaviour.
• No mechanism for certificate revocation — Kubernetes did not provide a built-in way to revoke TLS certificates, meaning compromised credentials could remain valid indefinitely.
• Unauthenticated HTTPS connections — Certain HTTPS endpoints did not enforce mutual authentication, leaving them open to impersonation or interception.
• Time-of-check/time-of-use (TOCTOU) race condition with PID handling — A race condition in process ID management could be exploited to interfere with workload scheduling or isolation.
• Improperly patched directory traversal in kubectl cp — A previously reported path traversal vulnerability in the kubectl cp command had not been fully remediated, potentially allowing a malicious container to overwrite arbitrary files on the host.

Beyond these five high-severity issues, the report also surfaced a range of lower-severity recommendations: cleaning up technical debt in the codebase, expanding test coverage, improving documentation, and hardening insecure defaults. These housekeeping recommendations are often the unglamorous but essential work that makes future vulnerability patching faster and safer.

Breadth vs. Depth: The Right Approach for a Project of This Scale

A common critique of broad security audits is that they trade depth for coverage. For a project as large and multifaceted as Kubernetes, however, the breadth-first approach makes practical sense. A targeted deep-dive into a single component — say, the API server’s authentication logic — would yield detailed findings for that subsystem while leaving the rest of the attack surface unexamined.

The holistic view produced by this audit is more useful for prioritisation. Maintainers and the CNCF security SIG can now see where the overall security posture is weakest, allocate resources accordingly, and commission follow-on deep-dive audits of the areas that warrant them. Think of it as a general health check that identifies which specialist referrals to make next.

Benefits for Maintainers: Proactive vs. Reactive Security

One of the most important takeaways from this audit is the value of finding your own vulnerabilities before others do. When a security flaw is discovered and disclosed by an external researcher or, worse, exploited in the wild, maintainers are forced into crisis mode: patches must ship under time pressure, communications must be carefully managed, and users are left exposed in the interim.

A planned security audit changes that dynamic entirely. Maintainers know about the findings in advance. Fixes can be prioritised thoughtfully against other roadmap commitments. Coordinated disclosure timelines can be agreed upon. The result is a more orderly and effective remediation process — and a lower risk of security incidents affecting end users.

Benefits for the Community: Transparency Builds Trust

By open-sourcing the full audit findings — including the white paper and threat model — the CNCF gave the wider Kubernetes community something valuable: the ability to make informed decisions. Organisations running Kubernetes in production can review the findings, assess their own exposure to the identified issues, and take compensating controls where necessary while waiting for upstream fixes.

This transparency also delivers a second benefit: it signals that the project takes security seriously as a first-class concern, not an afterthought. For enterprise adopters evaluating Kubernetes against competing platforms, a published, third-party security audit is meaningful evidence of security maturity.

Finally, the audit artefacts — particularly the threat model — are useful educational resources for anyone looking to deepen their understanding of Kubernetes internals or cloud-native security concepts more broadly.

Key Lessons for Other Open-Source Projects

The Kubernetes security audit offers a replicable model that other open-source projects — especially those handling sensitive workloads or infrastructure — should consider adopting:

1. Commission third-party audits proactively. Internal code review, however thorough, cannot fully replicate the perspective of an independent security team with no prior assumptions about the codebase.
2. Scope audits across control families, not just individual components. A cross-cutting assessment reveals systemic weaknesses that component-level reviews miss.
3. Publish the findings. Open-sourcing the results — not just the patches — builds community trust and accelerates collective learning.
4. Pair findings with actionable goals. Short-term and long-term remediation targets give maintainers and contributors a clear roadmap rather than an undifferentiated list of problems.
5. Treat the threat model as a living document. A threat model produced during an audit is a starting point, not a final answer. It should be updated as the project evolves.

Getting Involved: The CNCF Security SIG

If you want to follow the ongoing security work in the Kubernetes ecosystem, or contribute to future security audits, the CNCF maintains a Security Special Interest Group (SIG Security). The SIG coordinates security reviews, policy guidance, and disclosure processes across CNCF projects. Details on joining can be found through the official CNCF GitHub organisation and community pages.

Conclusion

The CNCF’s decision to commission, and then openly publish, a comprehensive security audit of Kubernetes was a landmark moment for cloud-native security. It demonstrated that even the largest and most complex open-source projects can take a structured, transparent, and proactive approach to security. The five high-severity findings identified in the audit serve as a reminder that no project — regardless of its maturity or community size — is immune to serious vulnerabilities. More importantly, the audit shows that the right response to that reality is not silence, but structured, open engagement with the security community.

For DevOps and platform engineering teams running Kubernetes, the practical takeaway is clear: review the published findings against your own cluster configurations, follow the upstream remediation progress, and consider commissioning your own security assessments for the internal platforms and tools your teams build and maintain.

Overview

Misconfigured Jira instances operated by well-known technology companies, government bodies, and educational institutions were found to be exposing sensitive internal data to unauthenticated users on the public internet. The exposure included employee names, email addresses, job roles, and details about ongoing projects — information that could be exploited for reconnaissance, targeted phishing, or competitive intelligence gathering.

The issue was discovered and disclosed by Avinash Jain, a security engineer, who reported findings to affected organisations including NASA and the United Nations. BleepingComputer independently verified that the misconfigured instances could be located using advanced search operators (commonly known as Google Dorks).

What Is Jira and Why Does It Hold Sensitive Data?

Jira, developed by Atlassian, is one of the most widely adopted project management and issue-tracking platforms in the world. Agile engineering teams use it to track tasks, bugs, sprints, and releases. Because Jira sits at the heart of development workflows, it inevitably contains details about internal projects, team structures, personnel, and organisational priorities — making it a high-value target if access controls are misconfigured.

The Root Cause: A Visibility Misconfiguration

According to Jain, the core problem lies in how Jira Cloud handles the default visibility setting for filters and dashboards. When a user creates a new filter or dashboard, the default sharing option is set to “All”. Many administrators and users reasonably interpret this to mean “all members of the organisation,” but in practice it means all users on the internet — including unauthenticated visitors.

Two configuration paths contribute to this exposure:

• Public filter and dashboard sharing: Jira Cloud allows filters and dashboards to be shared with a “Public” option. Atlassian’s own documentation warns that “if a filter or dashboard is shared with Public, the name of the filter or dashboard will be visible to anonymous users.” Many organisations enabled this without realising the full scope of what becomes accessible.
• Global Permissions — “Anyone” access: In the Global Permissions menu, administrators can grant access to users who are not logged in by selecting “Anyone” from a drop-down list. Atlassian’s documentation explicitly notes this is not recommended for systems accessible from the public internet, such as Jira Cloud. Despite this warning, many organisations left this setting enabled.

Once anonymous access is enabled at either level, Jira’s built-in user picker functionality can be used to retrieve a complete list of usernames and email addresses registered on that instance — without any authentication required.

How Misconfigured Instances Were Discovered

Jain used Google Dorks — carefully crafted search queries that leverage advanced Google search operators — to identify publicly accessible Jira instances exposing user and project data. This technique requires no special tools or credentials; it relies entirely on data that search engines have already indexed from misconfigured public-facing servers.

BleepingComputer confirmed that applying these search operators surfaced government domains, private companies, and educational institutions among the affected instances. The breadth of exposure was significant: Jain reported finding misconfigured Jira accounts across hundreds of companies, including organisations listed in the Alexa and Fortune top rankings.

“Thousands of companies’ filters, dashboards and staff data were publicly exposed. I have discovered several such misconfigured JIRA accounts in hundreds of companies. Some of the companies were from Alexa and Fortune top list including big giants like NASA, Google, Yahoo, etc and government sites.”

— Avinash Jain, Security Engineer

Organisations Affected

Named organisations reported to have been affected at the time of discovery included Google, Yahoo, NASA, Lenovo, 1Password, Zendesk, and a number of government bodies worldwide. Jain responsibly disclosed his findings to affected parties. Notable acknowledgements he received include:

• NASA: A previously discovered misconfigured Jira server exposed the names and email addresses of approximately 1,000 users. Jain reported this responsibly and was recognised by NASA.
• United Nations: The UN acknowledged Jain’s disclosure and recognised his role in improving their security posture.
• CODIX: A financial software solution used by European Union institutions and agencies, which also recognised Jain’s responsible disclosure.

Why This Matters: Reconnaissance and Attack Surface

Leaking employee names, email addresses, and project details may not seem as immediately dangerous as exposing passwords or financial records, but this data is highly valuable for attackers in the early stages of an attack:

• Spear phishing: Knowing which employee works on which project — and their email address — enables highly targeted phishing emails that are far more convincing than generic attempts.
• Social engineering: Role and project information helps attackers impersonate colleagues or vendors credibly.
• Competitive intelligence: Exposed project names, sprint goals, and task descriptions can reveal product roadmaps and strategic initiatives to competitors.
• Credential stuffing preparation: A validated list of real email addresses from an organisation can be fed directly into automated credential stuffing attacks against other services.

How to Audit and Fix Jira Visibility Settings

Jira administrators should review the following settings to close these exposure paths:

1. Review Global Permissions

Navigate to Settings → System → Global Permissions. Check whether “Browse Users” or “Use Jira” permissions are granted to “Anyone (including anonymous users).” Remove anonymous access unless there is a documented and deliberate reason to allow it.

2. Audit Filter and Dashboard Sharing

Review all shared filters and dashboards. Any item shared with “Public” or “All” should be reassessed. Change sharing to specific groups or projects rather than organisation-wide or public defaults.

3. Disable Anonymous Access to Projects

For each project, check Project Settings → Permissions. Ensure that “Browse Projects” is not granted to “Anyone” unless the project is intentionally public-facing.

4. Restrict User Picker Access

The user picker API endpoint can enumerate all users on an instance when anonymous access is enabled. Restricting anonymous access at the Global Permissions level prevents unauthenticated enumeration.

5. Use Atlassian’s Built-in Security Advisor

Jira Cloud includes a Security Advisor tool under site administration that flags common misconfigurations, including overly permissive anonymous access settings. Run this regularly as part of routine security reviews.

Key Takeaways for DevOps and Platform Teams

• Default settings in SaaS tools are not always secure by default — always validate permission configurations after initial setup and after major upgrades.
• “Visible to all” in a cloud tool frequently means the entire internet, not just your organisation. Read documentation carefully.
• Regularly audit third-party project management and collaboration tools as part of your organisation’s attack surface management programme.
• Google Dorks are a free, low-skill method attackers use to find misconfigured systems. If an attacker can find your Jira instance this way, you will want to know before they do.
• Responsible disclosure by external researchers is valuable — organisations should have a clear vulnerability disclosure policy and acknowledge reports promptly.

Open-source projects underpin many of today’s popular apps, software packages, and online services.

If a vendor releases code to the open-source community, license restrictions are removed and software can be integrated into other systems. From Google’s end-to-end encryption system E2EMail to the Netflix cross-scripting site vulnerability scanner Sleepy Puppy, open-source development is thriving and thousands of developers contribute their time to improving coding and ferreting out bugs every month.

There are ongoing open-source projects which have been built upon for years, but as the technology space evolves and moves into new areas.

According to open-source software management provider Black Duck Software’s ninth annual Open Source Rookies of the Year report, in 2016, the best, new open-source projects to be found online in the past year relate to the blockchain, database data analysis, deep learning, network agility, container clutter removal, network security, and ed tech.

The 2016 Black Duck Open Source Rookies of the Year are below:

1. Sawtooth Lake | Blockchain: Intel’s new distributed ledger platform for the Hyperledger blockchain, which was developed to boost the scalability and security of existing blockchain technologies.

2. CarbonData | Big Data: A fresh approach to data organization, multi-level indexing, and optimization for more-efficient use of computer resources.

3. Deep Scalable Sparse Tensor Network Engine: DSSTNE (“Destiny”) | Deep learning: Destiny focuses on neural network development for data sparseness and scalability, as well as the optimized use of multiple GPUs.

4. OpenCORD | Software-defined networking: An end-to-end solution which combines SDN, NFV, and cloud with commodity infrastructure to bring datacenter-grade scale and agility to vendors.

5. Poseidon, Trireme | Network security: The Poseidon project provides situational awareness to items being added or removed from networks, as well as the traffic being generated, while Trireme allows the creation of security policies through end-to-end authentication and authorization.

6. Ansible Container | Containers: The result of the Ansible development team’s desire for an alternative to Docker files, Ansible Container works to automate the container build, deployment, and management process using nothing but Ansible Playbooks.

7. Kolibri | Edtech: Kolibri seeks to make learning resources available to students and teachers in areas with limited education resources.

“The selections for 2016 show how diverse and ambitious open source software development has become,” said Patrick Carey, Director of Product Management at Black Duck who heads the annual Rookies selection process. “From communications to healthcare and beyond, they offer innovative solutions to a range of consumer and enterprise-grade problems.”