Hello my folks, welcome to the fascinating world of Gitlab. Nowadays, this has become a real use of every programmer/developer. You know every programmer needs some space to situate their projects and code which have been made by them. Today, in this Gitlab mainstream, we are going to elaborate on the SSH key in this you will learn about the fact of how can you create, manage with the SSH key.

What is an SSH key?

Let’s get started with SSH. SSH stands for secured shell and now, comes to the place of uses what is the use? This is used for authentication, by setting SSH you can connect to the Gitlab server without using a username and password each time. Once, you will set the SSH key so, you may skip using your username and password each time to connect your Gitlab server.

How to set up an SSH key in Gitlab?

Let see, what will have to do here?

Step 1: Run command SSH- keygen

You will have to run this command. If you are on MacBook, you can put terminal and will run the command SSH-keygen. You may enter the location or file where you have to save the key and press the enter key. So, you will have your ssh key created. This was on mac.

On mac. – run command on terminal

On windows – use putty or Git bash

If you are on windows then you can use an application or a client called putty, it is ssh client that you can use on windows or you can also use Git bash to run the command. If you will have installed it before, you will go to your windows system and search for Git bash. And you will adjust fonts if you will need them. So, you will run $ ssh-keygen then it will ask you to enter the file do you want to save it then again, you will press the enter so, it will have been created. You will go to your folder from local disk to .ssh in that two files will be created in the id_rsa and id_rsa.pub

Now, step no.2 will be

Step 2: log in to Gitlab account

                        Go to an account >> Settings >> SSH keys

So, you will go to your Gitlab and log in. you will sign in to your account if you will go to your account or profile at the top right. You would find settings there and if you will go in that. So, you will find an option for SSH key then you will click on that. You would add the content of your file id_rsa.pub. If you will go to the file and open it with any text editor like notepad and notepad++, you can copy the entire thing from there. And you will paste it to the SSH key. Suppose, you want to give a name to your key then you can add that name in the title option and switch to add key. So, you will see that everything would be edited there. There would be a key that you can use to authenticate and log in to the Gitlab server.

Now, here step no.3 is

Step 3: copy contents of id_rsa.pub and add key

Step 4: verify SSh key is added

 You have been seen. This is how you can add an SSH key to your Gitlab. I wish this all will be very useful for you.

Related video:

Hello techies, welcome to the real world of programming. Today, we are going to talk about the Git command line. Whether you will read this article fully so, I’ll do promise that you will get all control over the git commands until the end. It means as many commands, after this article, you will learn yourself through the command line, you can use full git. It is the best way because if you use GUI directly on any website, GUI comes in understand that all right but doing directly upload, this is not a right way, it is a practical process. What you will do, when the file will be large. This thing we are going to do through git command line that very command comes in the hands of the programmer. If we use a command line. So, let’s start with the elaborative part of this article. This article till the last, if you will have fear regarding command line becomes black from behind so, all your fear will vanishes.

How to install git on windows 10?  

So, let’s look. What you will do first? First, you will do a search on the web like git for windows download through enter click. You will get all downloads over there. As you will open by clicking the first option then it will directly reach you in windows. And there, your download will be started, what so if you will do manually then download will be started. One of the websites like git scm.com, from this you will download that git. So, this is not big stuff to install this, the normal default setting is there next-next as you install. Likely, you will install it. When the git will be downloaded then you will click on it, they will ask for permission. After doing the default setting, next-next, you will install that. When the installation will have done so, you will make a new folder from the name all about git. Under that folder, you will use git. If you want to check git is installed or not then you will do one right-click and you will see two options there like git bash here, and git GUI here. These two commands will come if you will do one right-click. You have a folder from the name all about GIT, if you want to do all work in that folder so, you will use the GIT bash here option according to the git command line, instead of GIT GUI here.

GIT command line tutorial

You will open the GIT bash here. There will open with the dialog box, you will do resize with maximize option. What will you do next, firstly, if you would install GIT on your desktop? So, what types of things, you will have to do. That is not so important to do but you have to do so, your name, who are making and uploading on GitHub, all this information comes from there. Now, let’s do configurations of these, first, we shall write like this 

            $ git config ¥- global user.name Mohan and as you will press the enter key then configuration key name will come like this,

          Mohan@LAPTOP- CR327854 MINGw64  ~/Desktop/All about git (master)

Usually, we will do a configuration of email,

            $ git config – -global user.email beaproplayer24@gamil.com and it will save like this,

Mohan@LAPTOP- CR327854 MINGw64  ~/Desktop/All about git (master). At the apex, there will be written like a master, you will understand about all this thing in upcoming part. How can you make a branch of your own and do a clone of it? Now, you have to check that your configuration has done or not so, you will right like this way, 

            $ git config – -global user.name Mohan, only you will write much like then your name will be print like this way,

            Mohan@LAPTOP- CR327854 MINGw64  ~/Desktop/All about git (master)

Git configurations

Now, the Configuration has been done. All that command, you were doing in previous then only you will put some key so, all of your commands will be done. If you put $ code . So, this is a shortcut to open your vs code through the terminal. So, your next query will be what is terminal? It is the terminal of UNIX that you are using in your windows. That terminal in mac which has UNIX- based, that GIT, is also a Unix-based terminal, you can also use it as a terminal. When you put $ code .  In that the vs code will open so, every file you will make in that. Those you want to upload in GitHub so, let’s have a look at how you can do that. If the new file you have to make, whenever you use GIT then what command do you move in first.

Initializing GIT repository

Whenever you make a repository, what command do you make first? A repository is a folder in that your projects may exist, whenever you move GIT. So, to the name of $ git init, you have to move that. When you do GIT init then there will come in written like initialized empty GIT repository in C: /users/Mohan/Desktop/All about GIT/.git/ it means to the name.GIT folder has come in file explorer but you will not see then after doing click on hidden items then to the name.GIT folder will have arrived there but you will not tease them and will hide them again. So that, you will again go to the command line and you want to see in the command line what type of folder is hidden there. So, there will be commands like $ ls – lart, all your hidden files will show you. This is the command, you can easily get it. There is a command, you will always use in GIT for knowing status such as $ git status then it will show information like branch master, commit yet, and untracked files. These all happen as untracked, modified, unmodified, and staged areas, firstly you, let’s understand about this. You have made a command line, installed and you are using it.

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:

Here are five non-technical skills that IT professionals and business employees should develop to support a successful cloud initiative.

1. Project Management

Cloud migrations involve coordinating a large number of moving parts — workload assessments, vendor selection, cutover scheduling, rollback planning, and team communication. A skilled project manager brings the planning and tracking discipline needed to keep all of these elements organized and progressing toward defined milestones.

Project management skills are also directly applicable to ongoing cloud operations. Estimating labor requirements, tracking cloud service consumption against project scope, and coordinating between engineering, security, and finance teams are all day-to-day project management responsibilities in a cloud environment.

For those looking to formalize this skill set, structured certifications such as the Project Management Professional (PMP) from the Project Management Institute provide a recognized credential that applies well beyond IT-specific programs. Agile and Scrum certifications are also increasingly relevant in cloud-native development contexts.

2. Domain and Business Analysis Skills

“Business skills” is a broad label, but in the cloud context it refers to a specific and valuable capability: understanding the core business processes that cloud systems are being built to automate or support. These subject-matter experts — often business analysts who have moved into IT roles — bring deep knowledge of a particular sector such as banking, healthcare, retail, or manufacturing.

They may not know the specific language an inventory control system is written in, but they understand what the system must do, how it fits into broader business workflows, and what constraints it must satisfy. Critically, they can translate those requirements clearly to systems designers, architects, and database analysts.

Without this perspective represented on a cloud project team, IT teams risk completing technically sound implementations that miss core business requirements. Common examples include overlooking industry-specific compliance obligations — such as restrictions on how personally identifiable information (PII) can be stored or processed — that should have been factored in from the start.

3. Cloud Financial Management (Accounting)

Cloud spending has grown substantially for most enterprises. Organizations that once managed modest monthly cloud bills now regularly deal with invoices that run into five or six figures per month. At that scale, financial discipline is no longer optional — it is a core operational requirement.

Someone with accounting or financial management expertise can monitor cloud costs in real time, establish spending budgets, set alerts and hard limits, and intervene before overspend becomes a serious problem. While CPAs and bookkeepers typically manage enterprise financials, cloud administrators and developers who understand budgeting concepts — such as reserved versus on-demand pricing, cost allocation tagging, and chargeback models — give their teams a measurable operational advantage.

Major cloud providers offer native cost management tooling (such as AWS Cost Explorer, Azure Cost Management, and Google Cloud Billing reports) that makes this skill more accessible to non-accountants. Familiarity with these tools is now a practical expectation for cloud operations roles.

4. Legal Acumen

Legal considerations in cloud computing extend well beyond the compliance frameworks most IT teams are already aware of, such as HIPAA, GDPR, or PCI DSS. While data handling regulations are obviously important, broader legal awareness is increasingly valuable for cloud practitioners.

For example, tax treatment of IT assets can affect the economics of a cloud migration. If on-premises hardware has not yet been fully depreciated, moving workloads off that hardware before depreciation is complete may result in a net financial loss that offsets anticipated cloud savings. This kind of analysis requires legal and financial understanding that is rarely part of a standard technical background.

Other legal considerations include the transferability of software licenses to cloud environments, the enforceability and interpretation of service-level agreements (SLAs) with cloud providers, and cross-border data sovereignty requirements. While most organizations will retain qualified legal counsel for formal advice, cloud engineers and architects benefit from having a working understanding of the legal landscape in which their systems operate.

5. Executive Leadership and Sponsorship

Cloud initiatives require sustained organizational commitment that only executive leadership can provide. CFOs, COOs, and other C-suite stakeholders may interact with cloud platforms indirectly — or not at all — yet their decisions determine whether cloud projects receive funding, how priorities are set, and who is accountable for outcomes.

Without active executive sponsorship, cloud projects tend to stall. Budget requests go unresolved, cross-departmental blockers persist without escalation paths, and strategic decisions get deferred. Leadership teams that actively engage with cloud strategy — understanding the business case, accepting ownership of results, and communicating organizational direction — are a consistent differentiator between cloud programs that deliver value and those that struggle to progress.

For technical leaders, this means developing the ability to communicate cloud strategy and trade-offs in business terms. Translating technical risk, cost, and capability into language that resonates with executives is itself a critical non-technical skill.

Building a Well-Rounded Cloud Team

A successful cloud program requires more than a team of skilled engineers. Project managers keep migrations on track. Business analysts ensure cloud systems reflect real-world requirements. Financially literate team members prevent runaway spending. Legal awareness protects the organization from avoidable risk. And executive leadership provides the organizational will and resources to make it all possible.

Organizations that deliberately build these capabilities into their cloud teams — rather than treating them as secondary to technical skills — are better positioned to deliver cloud initiatives that succeed in practice, not just on paper.

CircleCI Adds Windows Support

CircleCI, a leading continuous integration and continuous delivery (CI/CD) platform, announced in August 2019 that it was extending its platform to support Windows developers for the first time. Prior to this announcement, CircleCI had focused exclusively on Linux and macOS build environments, leaving a large segment of the developer community without native support.

The new Windows support was built on top of Windows Server 2019, which Microsoft had released the previous year. CircleCI product manager for Windows, Alexey Klochay, cited developer demand as the primary driver: “We’re really happy to announce that we are going to support Windows because customers are asking for it. Windows comprises 40% of the development market, according to a Stack Overflow survey from earlier this year.”

Why Windows Support Matters for CI/CD

Windows developers were not without CI/CD options before this announcement — tools such as Azure DevOps, Jenkins, and AppVeyor had long served the Windows ecosystem. However, CircleCI’s pitch was one of integration, ease of use, and reduced operational overhead.

According to Klochay, the key differentiator is that developers can get up and running without requiring dedicated DevOps engineering support: “We give the power to developers to do exactly what they need to do at their own pace without getting locked into anything. We’re providing ease of use and ease of maintenance.”

In addition to simplifying onboarding, CircleCI emphasized its pipeline visibility features. “We are also giving companies tools to get better visibility into what everyone is building, and how everyone is interacting with the system,” Klochay said. For engineering managers and platform teams, this kind of cross-team observability into build pipelines is increasingly critical as development organizations scale.

Windows Server 2019 as the Technical Foundation

CircleCI credited improvements in Windows Server 2019 as making the integration significantly more practical than it would have been in earlier years. Klochay noted: “Because of all the changes that Microsoft has been introducing in the latest Windows Server, it has been a smoother experience than if we had to start a year ago.”

Key improvements in Windows Server 2019 relevant to CI/CD workloads include better container support (including Windows containers via Docker), improved integration with cloud infrastructure providers, and enhanced networking capabilities. These features make it more viable to run ephemeral, isolated build environments — a cornerstone of modern CI/CD systems.

A Maturing Windows Ecosystem

Nathan Dintenfass from CircleCI pointed to a broader cultural and infrastructural shift in the Microsoft ecosystem that made this move possible: “We have observed a maturation of the Windows ecosystem, and being more and more attracted to the kinds of teams that are investing in really high-throughput software delivery automation, while at the same time a maturation of the underlying cloud infrastructure that makes Windows available, and makes it much easier for us to operate.”

This maturation reflects a well-documented trend. Microsoft’s embrace of open-source tooling, Linux on Azure, WSL (Windows Subsystem for Linux), and a developer-first approach under CEO Satya Nadella has encouraged greater convergence between Windows and the broader DevOps ecosystem. CircleCI’s Windows support announcement was a concrete signal that third-party CI/CD vendors were taking notice.

Business Context: Series D and Market Expansion

The Windows announcement came shortly after CircleCI disclosed a $56 million Series D funding round. Expanding into Windows development was a logical growth strategy: with Windows representing a substantial share of the developer market, supporting it allowed CircleCI to address enterprise customers with mixed-platform development environments — teams building .NET applications, Windows services, or game development pipelines alongside Linux-based services.

What This Means for DevOps Teams

For DevOps engineers evaluating CI/CD platforms, CircleCI’s Windows support introduced a new option in a space previously dominated by Azure DevOps Pipelines and self-hosted Jenkins instances. Key considerations when evaluating it include:

• Build environment parity: Teams with both Linux and Windows workloads can now manage both in a single CI/CD platform.
• Ease of onboarding: CircleCI’s configuration-as-code model (using config.yml) extends to Windows executors, meaning teams can define Windows builds using the same familiar syntax.
• Cloud-hosted runners: Windows build environments are hosted by CircleCI, removing the need to manage Windows build agents yourself.
• Visibility and reporting: Centralized dashboards apply to Windows pipelines alongside Linux and macOS pipelines.

Organizations running mixed Microsoft and open-source stacks — common in enterprises with legacy .NET applications alongside newer microservices — stand to benefit most from this kind of unified CI/CD approach.

Summary

CircleCI’s 2019 addition of Windows Server 2019 support marked a meaningful expansion of its CI/CD platform beyond its traditional Linux and macOS base. Driven by customer demand, a maturing Windows cloud infrastructure, and a large addressable market, the move positioned CircleCI to compete for enterprise teams with Windows workloads. For DevOps teams evaluating CI/CD solutions, it represented a new option for achieving consistent, automated pipelines across heterogeneous build environments.

DevOps quickly becoming the key to promoting collaboration and improving organizational outcomes.

A growing number of software developers are turning to DevOps to bring high-quality applications to market quickly. DevOps is a top trend among software development companies. It’s allowing firms to reshape their organizational structure and practices to deliver reliable applications continuously and as needed.

DevOps can help you build a culture of collaboration between traditionally siloed development and operations units. With the innovative methodology, you can improve the customer experience and respond to market demands faster.

A Better Way to Bring Apps to Market

DevOps includes guiding programming teams in using technology to optimize workflows. Development and operations teams learn practices and leverage resources that promote successful collaboration. Moreover, it’s about a change in attitude toward cooperation and using technology to enhance the abilities of programmers.

On the development side, DevOps tools and methods empower programmers with an agile development process and objectives that are driven by the team mission. On the operations side, programmers can deliver stable builds, cut costs and improve how organizations respond to market demands.

Making the Most of DevOps

Software firms need to release new features as quickly as possible. The relatively new DevOps practice empowers organizations to bring applications to market and fix bugs fast. Furthermore, it eliminates problem areas and makes it simpler to deliver new iterations.

DevOps enables organizations to compete in a fiercely intense marketplace. It’s the latest weapon in the arsenal that enterprises use to compete with and outdo the competition.

A New Methodology for Success

Software platforms such as JFrog Artifactory and Docker Registry are the technological foundation of DevOps. JFrog technology empowers programmers by eliminating many manual, repetitive tasks.

The platform enables development teams to work in simulated live environments, eliminating bugs when a new application or iteration reaches operations. When bugs present a problem, both development and operation teams learn from the fix.

DevOps resources such as JFrog enable development and operations teams to learn and grow together. The practice of sharing knowledge across business units enables software development firms to meet market demands quickly.

JFrog software allows programmers to use containers and microservice architecture. The microservice architecture enables programmers to work with discrete pieces of software independently. This feature allows programmers to work free of application dependencies.

DevOps platforms and practices help programmers maintain a continuous delivery culture. The method reduces the waste of limited resources. Still, DevOps goes beyond the scope of programmers. It includes all organizational stakeholders in the development process, from executives to customers and everyone in between.

Bringing Teams Together With DevOps

The DevOps method brings development and operation teams together across the entire lifecycle of application development. As more organizations use applications to engage with customers and clients, it’s growing increasingly important to deliver reliable programs – and quickly.

DevOps empowers organizations to collect feedback from customers, executives, and programmers and use that information to develop actionable strategies. As a result, the DevOps method is quickly becoming the key to promoting collaboration and improving organizational outcomes. DevOps are the tools and a way of thinking that empowers organizations to combine their sum of human capital to deliver phenomenal applications at the speed of thought.

Why CI/CD Matters for Machine Learning Teams

Continuous integration and continuous deployment (CI/CD) are well-established practices in software engineering, but their value extends well beyond traditional application development. As data science and machine learning (ML) projects grow in organizational importance, the same discipline that makes software teams productive — frequent commits, automated testing, and reliable deployment pipelines — becomes essential for teams building and maintaining ML models.

ML projects face a unique kind of complexity: practitioners must blend advanced statistics, mathematical modelling, and software engineering, all while operating under real business constraints such as deadlines, limited compute budgets, and shifting requirements. CI/CD practices provide a structural framework that helps teams manage this complexity without sacrificing speed or quality.

Defining CI/CD in Plain Terms

Continuous Integration (CI)

Continuous integration is the practice of merging code changes into a shared repository frequently — often multiple times per day. Each merge triggers an automated build and test suite, surfacing integration problems early when they are cheapest to fix. In a data science context, CI checks can validate not just code syntax but also data schemas, feature engineering logic, and model training scripts.

Continuous Deployment (CD)

Continuous deployment extends CI by automatically building, testing, and preparing software for release. Teams that adopt CD can push updates to production reliably and repeatedly, reducing the risk associated with large, infrequent releases. For ML teams, CD pipelines can automate model retraining, evaluation against a holdout dataset, and promotion to a serving endpoint — all without manual intervention.

How Microservices Architecture Enables CI/CD for ML

Modern software is increasingly delivered as microservices — small, independently deployable services that communicate over well-defined APIs. Microservice architectures allow one component to be updated, tested, and released without disrupting other parts of the system. This property is particularly valuable for ML-driven products, where a model serving endpoint may need to be updated independently of the user-facing application that consumes its predictions.

Microservices also make it easier to keep data-related concerns — such as privacy compliance updates or schema migrations — decoupled from model logic. A pipeline can apply a data transformation change and validate downstream model behaviour in an isolated environment before promoting that change to production.

Reducing Technical Debt in Data Projects

Technical debt — the long-term cost of shortcuts taken during development — is a serious risk in ML projects. Common examples include:

• Undocumented data preprocessing steps that are difficult to reproduce.
• Hard-coded file paths or credentials that break across environments.
• Model training scripts that have never been tested outside a single analyst’s laptop.
• Missing version pinning for libraries and data dependencies.

Organizations that operate multiple deployment environments — development, staging, and production — are especially vulnerable. A CI/CD pipeline enforces consistency across these environments by codifying environment setup, dependency installation, and validation steps. This directly addresses one of the most common ML operationalization failures: a model that works locally but cannot be reliably reproduced or deployed elsewhere.

Where Managers and Project Leads Fit In

CI/CD is not purely a technical concern. Project managers and business stakeholders can contribute meaningfully to a CI/CD workflow, particularly through user acceptance testing (UAT).

UAT is a test phase that evaluates whether a system meets user needs and business requirements before it is released. In an ML context, UAT might involve checking that a recommendation model’s outputs are coherent, that fairness constraints are satisfied, or that a forecasting model meets an agreed-upon accuracy threshold on business-relevant metrics. Managers can define these acceptance criteria, giving the test team clear, measurable parameters for evaluating model quality. When UAT is integrated into a CI/CD pipeline, every new model version is automatically validated against those criteria before it can advance toward production.

This approach reduces costly late-stage discoveries and creates a documented audit trail of how and why model versions were approved or rejected.

Tooling Considerations for ML CI/CD Pipelines

Selecting the right tools is an important step when establishing a CI/CD workflow for machine learning. Several areas deserve attention:

• Version control: All code, configuration files, and — where feasible — data transformation scripts should be stored in a version control system such as Git. This ensures a documented history of every change that influences a model’s behaviour.
• Dependency management: Whether a team works in Python, R, or another language, package versions should be pinned and tracked. Tools like pip-tools, conda, or renv (for R) help maintain reproducible environments.
• Pipeline orchestration: Tools designed for ML workflows — such as those offered by major cloud providers or open-source orchestration platforms — can automate training runs, evaluations, and deployments as part of a broader CI/CD pipeline.
• Model registry: A model registry records which model version is deployed to which environment, making it straightforward to roll back if a new version introduces a regression.
• Monitoring: Deployment is not the end of the pipeline. Automated monitoring for data drift and model performance degradation closes the feedback loop and can trigger retraining pipelines when thresholds are breached.

Major cloud platforms have invested heavily in managed services that address these needs, including faster model training, improved workflow management, and integrated security for model deployment. Open-source tooling has grown substantially in this space as well, giving teams options regardless of infrastructure preference.

Aligning CI/CD Cadence with ML Training Time

One practical tension in ML CI/CD is the time required to train a model. A typical software CI pipeline runs in minutes; a deep learning training job may run for hours or days. Teams need to design their pipelines with this asymmetry in mind. Common strategies include:

• Running fast smoke tests (on a small data sample) on every commit, reserving full training runs for scheduled jobs or significant code changes.
• Caching intermediate artefacts — such as preprocessed datasets or partially trained model checkpoints — to avoid redundant computation.
• Separating the code CI pipeline (fast, runs frequently) from the model training pipeline (slower, triggered by data or model code changes).

Thoughtful pipeline design ensures that the CI/CD process accelerates delivery rather than becoming a bottleneck of its own.

From Data to Business Decision

Translating raw data into a reliable, repeatable business decision is difficult. The gap between a promising notebook prototype and a production model that teams trust enough to act on is where many ML projects stall. CI/CD practices — version control, automated testing, consistent environments, and systematic deployment — directly address the failure modes that cause that gap.

As ML becomes embedded in more products, services, and software-managed devices, the discipline of CI/CD is no longer optional for data teams. Organisations that apply these practices early build a foundation for iterating on models safely, maintaining them at scale, and aligning their outputs with the business requirements that make them valuable.

The Provocative Claim: “Coding Is Dead”

In February 2017, Nitin Rakesh, then newly appointed CEO of IT services firm Mphasis, made a statement that ricocheted around the industry: “Coding is dead. I don’t need to do any native development anymore.” Speaking to BusinessLine, Rakesh argued that large public cloud platforms — Amazon Web Services (AWS), Salesforce, Microsoft Azure, and IBM Watson — had fundamentally changed how software is built and delivered.

The claim was deliberately provocative, but the underlying point deserves careful examination rather than a knee-jerk reaction. What Rakesh and other executives were describing was not the end of programming as a discipline, but a structural shift in how software is assembled and delivered at enterprise scale.

What “Cloud First, Mobile First” Actually Means for Engineers

Rakesh’s argument centered on a straightforward observation: banks and enterprises that once wrote custom code in native Java on Unix machines are increasingly running workloads on managed cloud platforms. On those platforms, much of the heavy lifting — infrastructure provisioning, runtime management, security patching — is handled by the provider.

The practical consequence for engineers is a shift in the value chain:

• Less time writing low-level boilerplate. Billions of lines of open-source code are freely available and can be composed — much like assembling Lego bricks — rather than written from scratch.
• More time on configuration and integration. As Rakesh noted, frameworks such as Node.js allow engineers to orchestrate existing routines rather than write native implementations from scratch.
• Faster time to market. Reusing battle-tested components reduces development cycles and shifts competitive advantage toward teams that can integrate quickly and iterate rapidly.

The KPMG Counterpoint: Programming Knowledge Still Matters

Not everyone accepted the “coding is dead” framing without qualification. Akhilesh Tuteja, Partner and National Head for Technology and BPM at KPMG, offered a more nuanced view:

“It is true the way we program today may not exist in the near future, as there’ll be more of reusable code that’ll be in play. However, you will require some level of programming knowledge to understand how to put these blocks together and make sense of them.”

Akhilesh Tuteja, Partner and National Head (Technology and BPM), KPMG

This is the more defensible position for working engineers. Composing cloud-native services, configuring infrastructure-as-code pipelines, writing Terraform modules, or building serverless functions all require genuine programming literacy. The abstraction layer has moved up, but it has not disappeared.

Automation Accelerates the Shift

Platforms such as AWS, Azure, and IBM Watson do not just provide managed infrastructure — they also provide tooling that automates testing, deployment, and monitoring. What once required days of manual testing can be triggered with a single pipeline step. This is the DevOps proposition in practical terms:

• CI/CD pipelines automate build, test, and release cycles.
• Infrastructure as Code (IaC) tools like Terraform and AWS CloudFormation reduce manual provisioning to configuration files.
• Managed services (databases, queues, identity, ML inference) replace large categories of custom code with API calls.
• Low-code and no-code platforms extend development capabilities to non-specialists for well-defined problem domains.

The cumulative effect is that a small, skilled team using modern cloud tooling can deliver what previously required large groups of native developers — not because coding is irrelevant, but because automation has dramatically raised the productivity ceiling per engineer.

Industry-Wide Re-Skilling: What IT Services Firms Were Doing

By 2017, major Indian IT services firms — TCS, Infosys, Wipro, and Capgemini — were already investing heavily in re-skilling large portions of their workforces. The focus areas reported at the time included:

• Agile and Scrum methodologies
• Design thinking and rapid prototyping
• Cloud platform certification (AWS, Azure, GCP)
• Reusable-code and component-driven development

Patrick Nicolet, Group Executive Board member at Capgemini, was quoted summarizing the urgency: “If you look at delivery in digital, it is about design thinking, agile, rapid prototyping and everything that is fast and furious. The way we have designed our delivery so far is not fast and furious.”

What This Means for DevOps Engineers Today

The 2017 conversation anticipated trends that have only accelerated. For DevOps and platform engineers, the practical takeaways are:

1. Understand platforms deeply, not just syntax. AWS, Azure, and GCP are now primary engineering environments. Knowing how to wire services together securely and efficiently is a core skill.
2. Programming literacy remains non-negotiable. Writing Bash, Python, Go, or HCL (Terraform) is still essential — the abstraction layer has moved, not vanished.
3. Automation is the multiplier. Engineers who can build and maintain robust CI/CD pipelines, automated testing suites, and infrastructure pipelines consistently outperform those who cannot.
4. Reusability is an architectural discipline. Internal developer platforms, shared Terraform modules, and standardized container images are the modern equivalent of Rakesh’s Lego-block analogy.
5. Speed is the competitive variable. “Fast and furious” delivery — iterating quickly based on real user feedback — is increasingly what separates effective engineering organizations from slow ones.

The Verdict: Transformation, Not Death

“Coding is dead” was always a headline engineered for attention. The reality is more nuanced: the nature of software engineering is transforming. Low-level native development has a shrinking role at the application layer, while platform engineering, infrastructure automation, and systems thinking have a growing one.

Developers who adapt — learning cloud platforms, embracing automation, and mastering reusable-component architectures — are not facing obsolescence. They are becoming significantly more productive. Those who treat any single language or framework as a permanent career foundation, without adapting to platform-centric delivery, face a harder road.

The most durable skill, as it turns out, is the ability to learn — which is precisely what these executives were arguing in 2017.

Background: Why Developer Education Matters for Ubuntu

Linux’s longevity and reach are not the result of any single contributor — they stem from a broad, collaborative community of developers, sysadmins, and users. For a distribution like Ubuntu to keep growing, Canonical must continuously attract and educate new developers. That means lowering the barrier to entry and providing high-quality, practical learning resources.

In January 2017, Canonical addressed this directly by launching Ubuntu Tutorials, a structured platform built on top of Google’s open-source Codelab framework. The platform is specifically aimed at programmers, developers, and DevOps engineers — not end users looking to learn the desktop.

What Are Ubuntu Tutorials?

Ubuntu Tutorials are topic-specific, practical walkthroughs designed to give developers hands-on experience in a particular domain. Canonical described the format as similar to pair programming — guided, interactive, and focused — but something you can work through independently at your own pace.

According to Canonical, the tutorials cover development and DevOps activities on Ubuntu machines, servers, and devices. The goal is to move beyond passive documentation and give engineers a repeatable, step-by-step process they can follow and apply immediately.

Key Features of Each Tutorial

Canonical outlined several structural features built into every tutorial on the platform:

• Clear summary: A detailed overview of what you will learn before you begin, so you can assess relevance quickly.
• Difficulty level: Each tutorial is labeled by complexity, helping learners identify the right starting point.
• Estimated completion time: Time estimates are provided per step and for the tutorial as a whole, making it easier to fit learning into a real work schedule.
• “Where to go from here” step: Every tutorial ends with guidance pointing to related topics, follow-on tutorials, or further reading — keeping the learning path continuous.

Offline Access via Snap

One notable feature is offline availability. Canonical packaged the tutorials as a Snap, allowing developers to install the full tutorial content locally and work through exercises without an internet connection. The Snap version mirrors the same content and underlying technology as the web-based version at tutorials.ubuntu.com.

This is particularly useful for developers working in air-gapped environments, traveling, or operating in locations with unreliable connectivity.

Built on Google’s Codelab Framework

Ubuntu Tutorials are built on top of Google’s open-source Codelab tooling, the same framework Google uses for its own developer tutorials. This gives the platform a consistent, well-tested user experience and allows Canonical to focus effort on content rather than building a custom tutorial engine from scratch.

Community Contributions Welcome

Consistent with the collaborative nature of open source, Canonical is not building the tutorial library alone. The company opened the platform to community contributions and published detailed authoring guidelines for anyone interested in writing tutorials for tutorials.ubuntu.com.

If you were looking to contribute at the time of launch, Canonical shared a contributor guidelines document covering the standards and format expected of tutorial authors.

Why This Matters for DevOps Engineers

For DevOps teams already running Ubuntu on servers or building on Ubuntu-based images in CI/CD pipelines, Ubuntu Tutorials provide a practical resource for onboarding team members or standardizing how your team approaches common tasks. Because the tutorials cover server and device workflows — not just desktop usage — the content is directly applicable to real infrastructure work.

The platform represents Canonical’s broader strategy of making Ubuntu the default choice for developers by investing in tooling, documentation, and education around the developer experience.