DEV Community: Adrian Castilla

How to create virtual machines using QEMU

Adrian Castilla — Wed, 20 Sep 2023 21:40:16 +0000

Introduction

QEMU is one of the most powerful virtual machine client ever created but there's one issue with it, it's a command line program, that means it does not have a GUI (Graphical User Interface) for that reasons, not everyone chooses QEMU as it's virtual machine client but in this post, I will show you how to create a virtual machine with QEMU.
Before getting started, you need to know that we are going to be doing the examples in macOS so all the commands are exclusively valid on macOS but with a simple search, you can get their equivalent commands for Linux and Windows.

Why I'm doing this post?

This post is made mainly for all those Apple Silicon users trying to virtualise systems like Windows Server or Ubuntu Server, those systems are not ARM compatible and that means, they cannot be virtualised from a ARM machine like the M1 or M2 Macs. For that reasons im making this post, to try to help all those Apple Silicon users to virtualise their OSs.

Installation

As we cannot start the house by the top, first we need to install QEMU, to do so we can use homebrew, so we just need to run the following command:

brew install qemu

After doing this, we can check that the installation has been successful by executing the following command:

qemu-system-x86_64 --version

After executing those commands, you should have qemu installed on your device, now we have to create our disk image.

Creating a disk image

Before creating a virtual machine we have to create a virtual disk, to do so we have to execute the following command:

qemu-img create -f qcow2 nombre_de_tu_archivo.qcow2 tamaño_del_disco

Well, that may sound a little bit weird for you so let's 'decode' it :D
First of all we are using 'qemu-img' which is the command that makes us able to generate virtual disks compatible with qemu, then we are writing 'create' which does what it says, it creates the virtual disk and then the '-f' flag which stands for 'format' followed by 'qcow2', let's stop here to explain what qcow2 is.

What's qcow2?

qcow2 (QEMU Copy On Write 2) is the second version of the qcow format which is used by QEMU, it's function is to store the hard drive contents of QEMU. qcow2 is the format that replaces the first version of qcow. NOTE: qcow2 format has replaced the original qcow format, however QEMU still can mount both qcow and qcow2 disks.

Now you know what qcow2 is, we can proceed and create the virtual disk, this is how you should see the command:

Virtual machine creation

Choose the architecture

Once the virtual disk has been created, we can finally proceed and create our virtual machine, so the first step is to choose the architecture that we are going to use, commonly you will use x86_64 so you have to choose the command that has that suffix but if you want to use arm just choose the command that has that suffix and you are ready to go.

qemu-system-x86_64

Boot settings

Next we are to use the flag '-boot d' which indicates that we want to boot the machine from the CD-ROM, next we will use the '-cdrom' flag to indicate the machine the image that we want to load in the CD-ROM, following the flag we have to introduce the path to the ISO file of the OS we want to install.

-boot d -cdrom path_to_the_iso_file.iso

Virtual disk selection

Finally we have to use the '-hda' flag to indicate the virtual disk that we want to use, following the flag we have to introduce the path to the virtual disk that we created in the previous step.

-hda /path/to/virtual/disk.qcow2

Now all the steps are done and we should have the following command:

qemu-system-x86_64 -m memory -boot d -cdrom path_to_the_iso_file.iso -hda /path/to/virtual/disk.qcow2

Once we execute this command a new window should pop up showing the boot of the operating system that we have installed.

Final thoughts

This is how you can create any virtual machine of any CPU architecture on an Apple Silicon Mac, this is a thing that actually you can't do on VMware or VirtualBox which is extremely disappointing and with QEMU you are able to do it, there's a software called UTM available for macOS for free which is a 'graphical version' of QEMU but it's performance is not very great and personally I prefer working with QEMU, it's more difficult as you need to learn the commands and to work with the command line interface which is something that most of users don't like but also it's much more powerful and it's performance is faster than almost any other virtual machine client.

I hope you've enjoyed this quick post and you've found it helpful and let me know in the comments if you would like to see a more advanced post of QEMU seeing other commands to configure more advanced settings of the virtual machines.
See you next time :D

@EnvironmentObject in Swift

Adrian Castilla — Wed, 24 May 2023 19:31:38 +0000

Introduction

Property wrappers are so important in SwiftUI as they modify the state of our application. SwiftUI is an imperative programming language that means that we have to tell the app what we want exactly instead of declaring them all. Because of the paradigm of this language, we need some modifiers that make us able to modify the state of our app whenever we want, what is the reason of the existence of the property wrappers, they permit us to modify the state of our app. We have so many property wrappers but today we are going to talk about the @EnvironmentObject, which is a little bit difficult to understand but so so good to use in our apps and projects.

Disclaimer: How we continue I have to tell you how we are going to work in this article, we will have three views, a main view, a View2 and a View3 and we will send that information to all the views using the @EnvironmentObject property wrapper

Why @EnvironmentObject?

First of all, the number one question, why we do have to use @EnvironmentObject? Well, there are some reasons of why we use it, first of all, we have to understand how we pass information between views in SwiftUI. We have three main property wrappers that help us passing information between views, @StateObject, @ObservedObject and @EnvironmentObject, @StateObject make us able to send information to just one view, when we try to pass that info into more than one view we can run into some troubles. That's what @ObservedObject tries to fix, it send information to more views but we have to pass the information to the View2 before it can get into View3 that's the reason of existence of @EnvironmentObject, it send that information into a higher zone which is the environment of the app and makes us able to send that into every single view that we want, see it as the cloud, when we upload something to the cloud we can access to it from any device this is the same, decorating a value with @EnvironmentObject sends that value to the "cloud" (Environment) and makes us able to share it to any other view in the project so View3 will have access to the @EnvironmentObject without passing it through the View2.

Let's start working!

So, we will locate in our main view and we will create a variable which in this case will point to a view model and we have to mark it as @StateObject. Now, in the view of the same view we have to place the modifier .environmentObject() and inside the parenthesis indicate the variable that we have just created.

This is how it should look.
At this point, our viewModel is already in the environment now we can go to the View3 and add an environment object that points to the view model.

And that's pretty much it! Now you will have access to your view model from anywhere!
I hope you've enjoyed it and learnt a little bit about SwiftUI and how this wonderful and powerful property wrapper works which is my absolute favourite as it makes sending information between views so so easy!

Power up your apps, use URLSession to use APIs in Swift

Adrian Castilla — Wed, 15 Feb 2023 20:01:10 +0000

Introduction

APIs or Application Programming Interface, lets the developers to access data given by an external server. Almost every single app that we use in our daily life uses APIs; Instagram for example, it doesn't have the data of their users in the local storage of your devices, that data is in an external server and it gets retrieved by the developer when needed. An API makes us able to create so great apps, for example, we can create an image generator powered by dall-e using their API or we can create a books app and integrate the Google Books API to power up the user experience but, to be able to do that, you have to know how to do it and that's exactly what I am going to explain, how to use URLSession in Swift.
Actually, there are two ways to use APIs in Swift, the third party way, which is basically using a library called AlamoFire, adding it to your project with CocoaPods or the Swift Package Manager (SPM) and the official way which is using URLSession which is already integrated in Swift so you don't have to add libraries or something similar and honestly, that's the way I prefer. So, let's start learning how to use URLSession.

Interesting links

Google Books API documentation
Status codes by Mozilla
URLSession official Apple Documentation

Setting up a URLSession

First of all, you have to setup a URLSession, this is quite simple, just create a new constant called urlSession or anything else and access the singleton of URLSession
let urlSession = URLSession.shared

Set the url

Now, you need to set the url that you want, of course this has to be the url you want to make the request to, here, you have two ways to do it.

Way 1: Fixed url

In the case that you want to set a fixed url, and don't let the user to change anything to that url, meaning that, all the requests will be done to the same url, just create a constant and assign it the url as a string:
let address = "https://pokeapi.co/api/v2/pokemon/1/"

Way 2: Letting the user customise the url

If you want to make the user able to customise the url, changing different information and making another requests this is the way that you should follow. In this case you have to use something called URLComponents, this allows you to build the url from scratch setting manually everything, the host, the path, query...
First, we have to create an instance of URLComponents:
var urlComponents = URLComponents()
Now, you can proceed to build your url by setting every component of it.

The first thing is the protocol, access to the scheme property of URLComponents and assign it to the protocol that the url uses: (In the following example, the protocol used is https)

urlComponents.scheme = "https"

Now you have to set the host of the url: (In this case : www.googleapis.com)

urlComponents.host = "www.googleapis.com"

Once you've done this, its time to assign the path of the url, this is basically all the content between /: (In this case /books/v1/volumes)

urlComponents.path = "/books/v1/volumes"

Now, you have to set the query items, that means all the items that are customisable from the url, like the search or the api key, if you have more than one query item, you can access the property .queryItems, that will create and array with all the queries that you need, otherwise, if you have only one item, just access to the property .query: (In this example, we have two query items, q and key)

urlComponents.queryItems = [
    URLQueryItems(name: "q", value: search)
    URLQueryItems(name: "key", value: key)
]

Ok, lets explain that code, specifically, the URLQueryItems, well, it gets two parameters, name and value, the name its just, as its name specifies, the name of the query, in this case q and key, you can know the name of the query by looking on the documentation of the API that you want to use, and the value, its just the string, int or any other data that will be assigned to that query, in this case, we should create a variable called search and that variable will contain a string with the search that you want to make. The other query, key, is not necessary in every API, just in some of them, in this case is necessary so if you want to make this exact example, you will have to go to the Google Apis documentation and claim your API key there, of course, its completely free. This is how the whole code should look:

let search = "Harry potter"
let key = "Here you have to place your API key"

urlComponents.queryItems = [
    URLQueryItems(name: "q", value: search)
    URLQueryItems(name: "key", value: key)
]

Now, you have endless possibilities, you can make the user enter whatever he wants, you can create a TextField with a @State variable and pass that variable to the search and many other things, here, the limit is your imagination.

Coming back to queryItems, once they are placed, you just need to build the url by accessing to the .url property of URLComponents and saving it into a new constant:

let url = urlComponents.url

Now, before we start creating the request we have to make a final thing, force the unwrap of the url and if it finds a nil value, it will throw an error. We will do this using guard:

guard let url = url else {
    throw NSError()
}

Creating the request

First of all, we create the request using URLRequest:
let request = URLRequest(url: url)
Now, we have to say to the URLSession that we want to create a request, we have to do this by creating a dataTask:

let task = urlSession.dataTask(with: url) { data, response, error in
    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}
task.resume()

This can look a little bit tricky so let me explain you, first of all, you access the dataTask property of URLSession to create the request, dataTask requires an argument of type url, you have to pass it the constant url that comes from URLComponents, after that, we have a trailing closure with three variables, data (This will display us the size of the data requested), response (Response will display us the status code of the request plus the headers of the request in a json, if you don't know the meaning of the status code, I highly recommend you going into this page: Status Codes by Mozilla), and error (This will only give us data when an error appears, this will display information about the error, in the case that the request is successful, the value of error will be nil). After that, we have to decode the data given using an if let sentence, so we create a new variable called responseString and we assign it a String with two values, data and encoding, data will be the data parameter of the trailing closure and encoding will be .utf8 and finally, inside the curly braces, we have to put the code that we want to execute if everything goes ok, in this simple case, we will print the results (They will be printed as a json file). In this way, you've made a request to an external url to retrieve information from their server, but only with this you will not be able to use the information given in your app, for that you have to parse that json file received using JSONDecoder but that, is for another article. Also, and before I close this, you may have been notice that there is a final sentence that says:
task.resume()
This is because all the tasks that have just been initialised, begin in a suspended status, the .resume() property just starts the method, this is quite important as if you miss it, the task will never get executed.

I hope you've enjoyed the article and you learnt how to use URLSession, soon I will release the part 2 of this article, showing how to parse the JSON file received by the server to be able to use it in your apps. See you then.

How ChatGPT is going to help but also destroy new developers.

Adrian Castilla — Thu, 02 Feb 2023 16:54:05 +0000

First of all, What is ChatGPT? Well, ChatGPT is a chat-based artificial intelligence (AI) built by OpenAI using a technology called GPT-3, it is basically a chat where you can ask questions and the AI will answer like a real person, the funny thing is that ChatGPT is also able to give you code answers, for example, you can ask ChatGPT to solve your programming exercise and the results will be incredibly good, you will obtain a very well written code that works perfectly, the question here is, is this helpful for the developers? Well, in my opinion, it depends. So, if you are a senior developer with some experience and advanced knowledge about programming then ChatGPT could be a good option to help you with some stuff in your programs or apps, if you are having some issues with some functionality of your program then you can ask ChatGPT for some help because, as you are a Senior developer you should already have faced multiple problems so your programming skills are already developed, yes get better is always good but in this case, going to ChatGPT could be a great option, the problem is when that developer is less experienced, when you are starting to program, you have to make mistakes, learn from them and write tons of lines of code, with ChatGPT a young developer can fall into the temptation of asking ChatGPT for a solution for his problem and exactly here is where the problem comes. That young developer will just copy the code received by the AI, paste it on his program and voila, everything will be working fine but probably he doesn't even know how that code works, as i said before, to acquire experience in this, you need to make mistakes, write code and think about that, then you will evolve and improve your programming skills, if every single time that you have a problem you go to ChatGPT instead of trying to figure out the problem and the solution, then you will not improve your skills. However I also think that it could also be helpful for the young developers to figure out maybe another solution to his problem or maybe understand in a better way how something works as long as they have already tried to solve the problem by themselves. To conclude, I want to clarify that this is my opinion, your opinion may differ and is completely normal. Let me know your point of view in the comments below, thanks for reading :D