Starting something new in tech can be exciting, but it can also be a little overwhelming.
This week at LuxDev HQ, I got to work with some tools and concepts that are becoming an important part of my journey as an IT student. We covered everything from installing Anaconda Distribution and Git Bash to learning basic terminal commands and using Git through VS Code.
At first, some of these commands looked very simple. But I quickly realised that understanding the basics is important because these are the tools developers use every day.
Getting Started with Anaconda
One of the first things we worked on was installing Anaconda Distribution.
Anaconda was new to me, but I learned that it provides a convenient environment for working with Python and its libraries. Instead of installing everything separately and dealing with different dependencies manually, Anaconda makes setting up a Python environment much easier.
This was especially useful because I’m becoming more interested in data and Python-based development.
The installation itself wasn't particularly complicated, but it was a good reminder that before writing code, you need to make sure your development environment is properly set up.
A small setup problem can easily turn into a big headache later.
Getting Familiar with Git Bash
Next came Git Bash.
I had used Git before, but this week gave me a better understanding of working with Git from the command line.
Git Bash provides a terminal environment where I could run commands and interact with files and Git repositories without relying entirely on a graphical interface.
Some of the commands we practised included:
mkdir
cd
touch
echo
They might look basic, but they are useful building blocks.
mkdir
mkdir is used to create a new directory.
For example:
mkdir my-project
This creates a new folder called my-project.
cd
cd is used to move into a directory.
cd my-project
This takes me inside the folder I just created.
It sounds simple, but being comfortable navigating between directories becomes important when working with larger projects.
touch
We also learned how to create files using touch. In our case, we created a README Markdown file:
touch readme.md
This creates an empty readme.md file inside the current directory.
It was a simple command, but it helped me understand how files can be created directly from the terminal instead of always using the VS Code interface.
echo
Another command we practised was echo.
For example:
echo "Hello World"
This displays Hello World in the terminal.
We could also use echo to write text into a file:
echo "Hello World" > readm.md
Practising these commands helped me become more comfortable using the terminal instead of always depending on a graphical interface.
Learning Git Through Practice
The biggest part of the week for me was getting more comfortable with Git.
Git can seem confusing when you're first introduced to concepts like repositories, commits, staging and pushing.
But once you start actually using it, the workflow starts making more sense.
The basic idea we worked with was:
Make changes → Stage changes → Commit → Push
After making changes to a project, Git allows us to keep track of what has changed.
This is one of the things I appreciate about Git. Instead of having different copies of the same project everywhere, Git gives us a proper history of the changes we make.
Using Source Control in VS Code
We also learned how to push our changes using the Source Control section in VS Code.
This was probably one of the most practical things we covered.
Instead of running every Git command manually in Git Bash, VS Code provides a visual interface where we can see the files we have changed.
Our workflow was:
- Make changes to the project.
- Open Source Control in VS Code.
- Review the changed files.
- Stage the changes.
- Write a commit message.
- Commit the changes.
- Push the changes to GitHub.
Seeing everything directly inside VS Code made the Git workflow much easier for me to understand.
It also helped me realise that Git isn't just something you learn for the sake of learning it. It's something I'll probably be using regularly as I continue building projects.
What I Took Away From This Week
One thing I learned this week is that the simple stuff matters.
Commands like cd, mkdir, touch and echo aren't complicated, but understanding them makes working with the terminal much less intimidating.
The same applies to Git.
I don't need to memorise every Git command immediately. What matters right now is understanding the basic workflow and getting comfortable using it.
I'm also starting to see how the different tools fit together:
Git Bash → working with commands and files
Git → tracking changes to projects
GitHub → storing repositories online
VS Code → writing code and managing changes
Anaconda → managing Python environments and tools
Individually, these tools are useful. Together, they are becoming part of my development workflow.
Final Thoughts
Overall, this was a good week at LuxDev HQ.
There were moments where I had to stop and think about what a command was actually doing, but that's part of learning.
I'm beginning to understand that becoming better at tech isn't only about learning programming languages. It's also about becoming comfortable with the tools developers use to build and manage their projects.
This week was mainly about the fundamentals, but those fundamentals are going to matter as we move into more advanced topics.
I'm looking forward to seeing what we learn next.
One week down. More to learn.
Top comments (0)