DEV Community: Kendall Vargas

Java OOP: Week 2 - The OOP Adventure Continues

Kendall Vargas — Tue, 07 Jan 2025 19:57:14 +0000

In my first week I mentioned general topics about OOP, where I was able to learn quite a bit about these topics in a short amount of time. However, there were still topics left to cover. Taking into account that this is just the basics of OOP, I am in the process of deciding if Java will be the language I want to focus on 100%, even after finishing university, I have to say that I have a particular liking for the backend because of my experience in testing, which may be a factor in my decision.

During this second week I didn’t have much time to review topics like threads, enums, or generics that I had pending. However, I progressed on a small project simulating a restaurant, where the following actions can be performed:

Create products or meals 🍔
Place orders based on those products and indicate how many were consumed.
Display individual order after adding it.
Display all orders, with the option to add as many orders as the user wants.

I mainly created it to cover all aspects of OOP, including data validation, and to keep practicing logic. I have it almost finished but am still adding details; I’ll upload it to my repository once it’s ready.

Additionally, I covered another OOP topic and other topics that are extremely useful.

Which ones? Relational classes, try and catch, and files.

I will briefly mention how these topics have been useful to me and how I understand their practical applications.

Relational Classes

Relational classes are a topic that has taken me some time to understand and use. However, once you get the hang of it, they can be implemented easily. The way I’ve used this concept the most is the 1-to-N relationship, which is used to link multiple objects of a Class B to a Class A.

For example, if I want a car to have multiple owners, I need a relationship from the Owners class to the Cars class.

In the Car class constructor, a list (I’ve used ArrayList) needs to be passed, and this list is created based on objects from the Owner constructor. Thus, the owner with their attributes (name, age, ID, etc.) will be linked to a Car constructor, which will be able to create objects with these properties.

Here’s a simple example that shows how a 1-to-N relationship is applied: https://pastebin.com/dX6SDWwp

This is useful when you need to “connect” certain objects with others, so that you have a direct relationship and they are not just connected by arrays or another different method.

Try and Catch ⚙️

The use of try and catch in Java is something I’ve implemented more than in the other language I’ve used. I think this is because my IDE automatically suggests using try and catch for some exceptions that require it.

This topic is just a highlight compared to another language like C++, where I used it very little and preferred other techniques to avoid errors. However, I am gradually getting used to using try and catch to predict errors and avoid sudden system crashes.

Files - JSON/GSON - Serialization and Deserialization 📄

Working with files in Java took up 70% of my learning time last weekend. Despite this, I feel there is a bit more information and examples compared to C++, where I also implemented file usage with matrices to maintain data without rewriting it.

This was useful for systems like:

Shopping carts
Inventory management
Orders, or any system where data retention is necessary.

In this case, with Java, I need to use objects, so this involves serialization and deserialization.

Here I noticed a big difference, as the way of writing depends heavily on the type of data you want. My main issue, which took hours of research, was that when I saved characters to my .txt file, they appeared in binary format when opening the file, but they displayed as characters in the console.

I found online that there are two ways to read and write data:

Via bytes
Via characters

The method I was using was byte-based since I was passing objects directly.

I don’t yet feel knowledgeable enough to share the differences between the various ways to use the Writer and Reader subclasses, but I’m working on a real-world exercise where I’ll use objects stored in an ArrayList and learn how to serialize and deserialize them using GSON (to keep the objects in their state within the system in a .json file) and then write this data to a .txt file to store them as records in an organized way.

Closing

Last week, I didn’t make as much progress as I would’ve liked, but working with files took many hours of research, application, and concept differentiation, pulling bits from every article I reviewed to reach a final result that I’ll test in a “real” project and share how it went.

It’s important to mention that this specific handling and the scenario I mentioned with GSON and .txt is something I’m required to do for university. However, there are other ways, like JPA or databases, to handle this. It’s not strictly necessary to use GSON and .txt to maintain data in a system.

With nothing more to add, if anyone has any input on files or the topics I mentioned, feel free to comment and share your suggestions!

Happy coding! 🎉

Progress with Java - OOP

Kendall Vargas — Tue, 31 Dec 2024 15:33:09 +0000

After learning the basics of programming with C++ at my university, seeing mostly data structures, algorithms, file management, validations, functions, methods, in general, the basics of programming.

However, due to university issues, the next subject I have to take is Java, and due to my background as a Tester, I decided to learn how to use Selenium with Java, since it is one of the most used frameworks currently (last update in February 2024) and its use with Java especially, is perfect for both cases, I would kill 2 birds with one stone as we would say in my country! 🐦🐦

So I'm getting deep into OOP concepts, which are also essential in test automation.

Since I came from C++ and the basics, the first thing I did was learn Java syntax, how it works, logical operators, relational operators, try and catch, functions, methods, statements. The good thing about learning the basics well is that when you switch from one language to another, it doesn't become so difficult, since you only have to learn the syntax and some actions that are different from other languages.

This took me maybe the first day and the second day practicing with basic exercises that I've done in C++ and trying to solve them in Java, to familiarize myself with the syntax and some details that work differently, such as statements, access modifiers or reading data in the console.

Then I moved on to object-oriented programming, which has been a few days full of material, however, I feel that I have made a lot of progress with the concepts, a key is not to rush to learn, and to practice a lot when learning different concepts.

I would like to talk about how artificial intelligences serve to be your own teacher, how?: ask questions, make comparisons with concepts, ask exercises to see if you understood the logic of the concept or not, and much more, which I want to talk about in a separate blog, since there is a lot to talk about.

Java, being object-oriented, is ideal to start with these concepts:

Encapsulation
Inheritance
Polymorphism
Method overloading and overwriting
Abstract classes
Interfaces

These terms are quite complex, and it took me a lot of practice to be able to differentiate one from the other, I hope I'm not the only one! 😅

I still have a lot to improve, but I've tried to implement it in many exercises, and it's been quite useful to see how you can modulate the code with these techniques and save lines of code that in C++ I made it through functions or methods, which in the end, clearly is not the same.

Also, a big part of understanding OOP is contextualizing everything as an object. Thinking about something and being able to ask yourself:

What attributes does that object have?
What does this object do?

From here come the attributes and methods of a class. For example, the example that is always used:

A car:

What attributes does a car have? Tires, doors, brand, model, color, and so many more attributes
What actions can a car do? Accelerate, brake, park, reverse, turn and much more

The attributes and methods are derived from these, as well as any other object that is needed.

After learning these terms, I then moved to collections, which are structures that can grow without having to be defined like vectors and matrices, these collections grow as data is added.

Types of collections that I have seen these days:

ArrayList
LinkedList
Stack
HashMap

Each one has different functions and can be very useful, the one I have used the most so far has been the ArrayList, I love it for creating objects and adding them with the .add() method.

Something that I loved and learned about these collections, is the iteration over them, and the forEach method. I had seen it and I never even knew what it was, until now that I learned to use it, I have not used the conventional method again! This forEach method has a little more simplicity in the steps to go through the ArrayList, for example, you do not need to use list.get(i).

Creating an arrayList:

`ArrayList<String> list = new ArrayList<>();

// Adding items to the list
list.add("test");
list.add("another");
list.add("third");`

Normal for method:

`for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}`

forEach method:

`for (String element : list) {
    System.out.println(element);
}`

I thought that OOP was not going to be so complicated, since I had some knowledge, but seeing it from a programmer's side, it is quite complex and requires critical thinking to be able to use it in the best way.
I still have quite a few things to see, such as:
ENUMS, threads, generics, JPA

In total I have more than 50 packages in my repository, each one including approximately 3/4 classes, which means that in a quick estimate I have a little more than 200 classes created from pure exercises and learning with all this that I have mentioned, I plan to upload it to a repository soon with statements so that others can practice with the same!

I am almost done with this beautiful OOP topic, I will document how I did this week with the missing topics, and then fully carry out projects applying all the concepts studied, which is the most important thing.

Resources:
I have used courses in Spanish (TodoCode and Programacion ATS on YouTube), apart from a lot of Stack Overflow and official Java documentation.

If anyone is studying these topics and would like to exchange opinions on them, please feel free to contact me!

Thanks for reading, happy coding/testing!💻

My experience with Cypress Automation Framework: Tips and Insights

Kendall Vargas — Thu, 05 Dec 2024 14:20:31 +0000

🚀 My Journey with Cypress

When I started in the world of automation, one of the first tools I heard about, which I knew was well-positioned in the market, was Cypress. During my transition to learning automation, having already established a solid foundation in manual testing, I decided to learn how to use Cypress.

With little to no programming knowledge, in this blog, I’ll share my experience with this tool by highlighting the challenges I faced, the mistakes I made, and the tips that may help you overcome them. These insights might be useful if you’re interested in learning about automation or are just starting out.

💻 Programming

Although I had some understanding of programming concepts, one mistake I made was trying to dive into automation without solid programming knowledge. Why? Many times, automation scripts can become redundant. This is where creating modular code becomes important. Modular code is maintainable and easy to understand. After all, you’re not the only one who will read it; developers, POs, and other testers will too.

A common example is iterating over objects in a dropdown menu. For this, you can use loops, which simplify handling such elements. Similarly, you can manage errors with JSON files and 'for' loops.

It’s useless to copy code from an AI or other sources without understanding why and when to apply these structures. Trust me, it’s far better to know how to implement them. Even if you copy code, understanding its functionality is key to handling errors efficiently and avoiding spending three times longer debugging due to a mistake.

🔄 Cypress

At the beginning of my journey with Cypress, my first impression was that it was easy to understand the UI part, having a dashboard and a free cloud where you can see the test results, and so on. I liked the way Cypress has the commands file, which for repetitive actions was really useful.

This can be a personal opinion, but I felt that, compared to other frameworks I have used (Selenium), the code looks much cleaner and more understandable, the assertions are more readable, and the way it handles the elements is more intuitive.

Additionally, I found API testing very helpful, specifically using cy.intercept(). Intercepting APIs on the website and validating their responses can make your code more robust and help you avoid some errors when testing websites.

However, I struggled with certain locators, particularly the family locators (parent, child, siblings, and methods like nextUntil and parentsUntil). Sometimes they worked, but other times I had to find alternative approaches to handle elements. This largely depends on the website you’re testing and how it is structured. Sometimes, you won’t even need these locators. My conclusion is that understanding CSS and HTML is essential for effectively handling such elements.

📚 What resources do I recommend for learning programming and Cypress?

It depends on the programming language you want to learn and, above all, studying object-oriented programming. However, to use Cypress, you can only code in JavaScript or TypeScript.

There are hundreds of free programming courses on YouTube, Udemy, and w3schools that have excellent documentation and exercises. From my perspective, practicing while learning helped me understand the concepts. The key is being repetitive, curious, and consistent.

Learning loops and functions was very complex for me at first, but with practice, I understood the logic behind them, which is essential for programming.

For Cypress, I recommend starting with the official documentation. It's well-structured, easy to understand, and the best way to learn how to use the tool. After that, you can look for courses on Udemy, YouTube, or 🔗 Test Automation University 🔗, which offers different automation paths and teaches you the programming language needed for the respective path you choose.

💡 Things I would have liked to know before starting with Cypress

Initially, I thought Cypress documentation wasn't good enough to help with certain cases or as an introduction. I only watched YouTube and Udemy tutorials. However, Cypress has excellent documentation that covers topics like Continuous Integration, best practices, variables, and a lot of other things. If I had started by reading the documentation, it would have been much easier to apply these concepts in practice.
Don’t try to learn everything right away; programming and automation are complex and require time to understand everything and perform best practices. Each time you learn a new concept, apply it and practice it until you feel comfortable. Trust me, that will save you a lot of time.
A good way to learn is by exploring another repository and trying to understand the ‘why’ of some techniques. That’s something that helped me gain more knowledge and apply those techniques in ‘real-life’ scenarios, both for, automation and programming.
I made this mistake when I started developing my Cypress project: even though in practice you just create random test cases for some features, this is not the way you should handle your project. I strongly believe that first having an idea is key for the techniques you are going to use, understanding the website you are going to test and many other fundamentals like the Testing Pyramid will help you create a more solid project.
In automation, we don't need to automate everything (depending on the context), so if I were to try again from scratch, I would make a test plan or strategy about it before starting to automate.
Dependency: We must not have test cases that depend on some other feature, we need to have independent test cases because if we have 15 test cases and the first one fails, imagine having all 15 test cases fail because we depend on test case 1.
For personal projects this sometimes cannot be controlled, since you’re limited to a third-party website and you can’t have some additional control on your side to avoid dependencies on some feature, however, whenever test cases can be independent, it’s better.
Speaking of personal projects, when choosing a website to create your portfolio, select a website that doesn't constantly change or is publicly editable. Sometimes sandboxes or free pages for automation are open for anyone to modify, and this can affect your test cases.
It happened to me that some websites had significant traffic for automation, so people changed the language of the website, which affected my locators. Also, people deleted profiles, causing my tests to fail, and many other things that were a bit stressful. Try avoiding this kind of website.
🔗 Link 🔗 where you can find websites to practice your automation tests.

🕯 Additional Tips

Knowing the basics of testing is essential before starting automation. You won’t be able to apply testing concepts and a critical eye to features just because you’re using automation. It’s like driving a car without taking a theoretical exam, having prior knowledge is essential.
Don’t be afraid to ASK for help! Asking allowed me to connect with incredible people and learn a lot from them. If you’re stuck and don’t know what to do, ask a colleague, even on Reddit, Stack Overflow, or Udemy (mainly for paid courses), they always answer your questions.

I like to compare programming and automation with this phrase I heard a while ago: Practice makes progress, not perfection.

Thanks for reading, and happy testing!