DEV Community: Miguel Teheran

New Tech Roles Created by the Rise of AI

Miguel Teheran — Mon, 06 Apr 2026 22:58:22 +0000

Artificial intelligence has transformed many roles and responsibilities in the technology world. Since around 2010, we have seen data-related roles such as Data Analyst, Data Engineer, and Data Scientist. However, today the landscape goes far beyond analyzing data to build machine learning models.

The widespread adoption of AI — and more importantly, how it is applied within software projects — has created entirely new job positions. These roles are built on strong programming foundations, but their daily activities are fundamentally different, centered around interacting with, orchestrating, and operationalizing artificial intelligence.

Below are some of the emerging roles shaped by this new AI-driven era.

Intelligence Engineer

(Applied AI Engineer)

The Intelligence Engineer designs and integrates artificial intelligence capabilities into systems, digital products, and development processes. Their goal is to turn AI models into practical, scalable solutions that meet business needs by automating tasks, making decisions, and creating measurable value.

Key activities include:

Designing architectures that integrate AI models (LLMs, ML models, external APIs).
Building pipelines using RAG, embeddings, and vector databases.
Designing and optimizing structured prompts.
Orchestrating agents and autonomous workflows.
Evaluating and improving the quality of AI-generated outputs.
Implementing validations, metrics, and security controls.
Optimizing cost, latency, and overall model performance.

Agentic AI Expert

(Agent-Based AI Specialist)

The Agentic AI Expert specializes in designing, implementing, and optimizing systems built around autonomous AI agents. Their focus is creating architectures where multiple agents perceive, reason, make decisions, and execute actions in coordination to solve complex problems and automate end-to-end processes.

Key activities include:

Designing autonomous agents and agent-based systems.
Defining planning, memory, and decision-making mechanisms.
Implementing agents with access to tools, APIs, and databases.
Orchestrating communication and coordination between agents.
Evaluating agent performance, stability, and alignment.
Mitigating risks such as infinite loops, unintended actions, or goal drift.
Optimizing cost, latency, and efficient model usage. Integrating agentic systems into business products and processes.

Agentic Systems Architect

(Architect of Intelligent Agent-Based Systems)

The Agentic Systems Architect is responsible for designing the architecture of systems powered by autonomous AI agents. This role defines how multiple agents perceive information, reason, make decisions, and execute actions in a coordinated way — ensuring scalability, security, and alignment with business objectives.

Key activities include:

Designing scalable and resilient multi-agent architectures.
Defining memory, planning, and decision-making structures.
Designing coordination and communication mechanisms between agents.
Integrating agents with APIs, databases, external tools, and enterprise systems.
Establishing governance, control, and supervision rules for autonomous agents.
Mitigating risks such as infinite loops, unintended actions, or strategic misalignment.
Optimizing performance, latency, and model execution costs.
Collaborating with product and business teams to translate strategic goals into functional autonomous systems.

AI Product Manager

The AI Product Manager defines, designs, and leads AI-powered products. This role connects AI technical capabilities with business and user needs, making strategic decisions about model usage, risk management, user experience, and technical feasibility to ensure AI delivers measurable value.

Key activities include:

Defining the vision and strategy for AI-based products.
Identifying high-impact AI use cases.
Prioritizing features considering impact, cost, and risk. Collaborating with engineering and data teams on architecture and technical scope.
Evaluating performance metrics (accuracy, latency, cost, adoption).
Managing risks related to bias, privacy, and regulatory compliance.
Designing user experiences that integrate AI clearly and responsibly.
Continuously monitoring and optimizing product performance in production.

AI Tech Lead

The AI Tech Lead is the technical leader responsible for designing and overseeing the implementation of AI-based solutions within development teams. This role defines technical architecture, establishes best practices, and ensures AI systems are scalable, secure, and aligned with product and business goals.

Acting as a bridge between strategy, product, and engineering, the AI Tech Lead ensures technical excellence across AI initiatives.

Key activities include:

Defining the technical architecture of AI-driven solutions.
Leading the implementation of models, pipelines, and intelligent systems.
Establishing quality, security, and governance standards in AI projects.
Guiding teams on best practices for integrating LLMs, RAG systems, and agents.
Reviewing code and validating AI-generated outputs.
Making technical decisions regarding models, tools, and frameworks.
Aligning technical decisions with product strategy and stakeholder objectives.

Agentic AI Engineer

The Agentic AI Engineer designs, develops, and implements autonomous AI agents. They build systems where agents can perceive, reason, plan, and act independently — integrating with tools, APIs, and real-world environments to automate complex processes.

Their focus is turning AI models into operational agents that function reliably within production systems.

Key activities include:

Developing and implementing autonomous agents using LLMs and tools such as LangChain.
Designing memory, planning, and decision-making mechanisms.
Integrating agents with APIs, databases, and external tools.
Building multi-agent architectures and coordination workflows.
Implementing monitoring and behavior validation systems.
Optimizing latency, cost, and execution efficiency.
Testing, evaluating, and continuously improving agent performance.
Here are a few examples of new roles created by the rapid adoption of AI in products and business processes.

If you know other roles created by this technological revolution, feel free to share them in the comments.

How can a Junior Developer Defeat an AI?

Miguel Teheran — Sun, 22 Mar 2026 21:30:47 +0000

The massive use of artificial intelligence, along with the advent of new technologies and the release of hundreds of models and services based on this technology, represents a major shift in the paradigm of what it means to be a programmer and how we carry out our daily activities. Some time ago, I shared an article about what constitutes a new role for developers and programmers in the age of AI: taking on the responsibility of supervising what AI produces, in the article From Programmer to Supervisor of AI-Generated Code. This role is becoming more common, but also more challenging for those who must assume it — especially junior developers or those just beginning a career in technology.

The hiring dynamic has been transformed by artificial intelligence. However, we have not fully adopted the mindset of hiring junior developers who, together with AI, can generate projects and accelerate progress. On the contrary, many companies have chosen to reduce teams and rely on the best senior developers who, with their knowledge, expertise, and now AI skills, can maximize the value of these tools and focus on the most critical aspects of projects such as scalability, infrastructure, architecture, and product development.

Why is it more challenging for Junior developers to remain competitive in a world dominated by AI?

Junior developers face many challenges entering the industry today, influenced by several additional factors:

University students or those trained through online courses typically learn the fundamentals. However, in today’s work environment, many basic tasks are delegated to AI. This can limit opportunities for juniors to practice, make mistakes, and strengthen their technical judgment through direct experience.
There is also an expansion in the range of technologies and phases of the software development process that must be mastered. With AI, we now need to understand more stages of software development — from testing and automation with DevOps tools to the generation of Proofs of Concept (PoC). Since AI reduces the time required for technical tasks, creativity and broader system understanding are increasingly valued.
There has also been a paradigm shift in what is expected from a junior developer. We have moved from workshops and training programs to a reality with stricter requirements, where complex concepts, certifications, and experience with AI are demanded from the start.

Recommendations for Junior developers in the AI era

Although the landscape may seem challenging, we can highlight some actions to become more competitive and build the profile the market truly needs in this pivotal moment:

It is important to learn AI, not just use the tools. This includes understanding how LLMs are improved, prompt engineering techniques, agentic architectures, and the creation of intelligent agents. The deeper we go into these concepts and the more importance we give them, the better we will understand what AI does and how to use it effectively.
Use AI to understand and deepen knowledge across all phases of development. Unit and integration testing were often neglected or undervalued due to the time required for implementation. Now, any developer who understands testing concepts and knows the libraries used to build them can quickly generate all the tests a project requires.
Strengthen the foundations and core concepts of programming and AI. Now more than ever, understanding what a design pattern is, what an architecture like Clean Code represents, and knowing best practices is essential to critically evaluate what AI produces and what the product or client truly requires.
Value physical and mental health, continuous learning, and soft skills. Products are still designed for humans and for humanity, and creativity is becoming one of the most valuable differentiators in what we build. To enhance creativity, it is necessary to care for physical and mental health, maintain spaces for reflection, and cultivate a mindset of continuous learning.

Conclusion: The End of the Developer Who Only Types

We are witnessing the end of a stage in the profession: the developer whose main value was manually writing code for hours. AI can now generate functions, classes, complete APIs, and even functional prototypes in minutes. The purely mechanical task of typing code is losing relevance. But this does not mean the death of the developer. It means evolution.

In the new AI era, value no longer lies in the speed of our fingers, but in the depth of our minds. The professional who reflects, analyzes, questions, designs, and creates will be more necessary than ever. AI amplifies execution, but judgment remains human.

The competitive advantage will no longer be “who programs more,” but “who understands the problem better,” “who asks better questions,” and “who designs solutions with strategic vision.”

In this new stage, programming is more about finding solutions than just typing code; it reflects the core essence of engineering.

The Essential Skills of an AI Code Supervisor

Miguel Teheran — Thu, 04 Dec 2025 05:20:49 +0000

The software industry is undergoing a historic shift. In just a few years, we've moved from prohibiting the use of generative AI tools to making them an indispensable requirement for productivity. A few weeks ago, I published an article introducing for the first time the concept of an AI-Generated Code Supervisor (From Programmer to AI-Generated Code Supervisor). Continuing with this concept, this article delves deeper into the essential skills for this emerging role, which is rapidly becoming an industry trend.
This new, specialized role of AI Code Supervisor is a hybrid figure that combines critical thinking, deep technical knowledge, and professional judgment capable of detecting errors, inconsistencies, and incorrect decisions that AI cannot yet comprehend.
This role does not replace the traditional programmer but redefines their responsibilities and the way they apply their knowledge to complete daily tasks. Let's analyze the most important skills for this role.

1. Analytical Ability: The Fundamental Skill

The supervisor must assume that code generated by AI is not trustworthy by default - even if it compiles and looks correct.
AI can:

Misinterpret business rules.
Invent non-existent behaviors.
Overlook edge cases.
Produce code that appears correct but fails under real loads.
Regenerate files or portions of code while omitting crucial steps.

Therefore, analytical ability becomes the first and most critical skill. It involves:

Deeply understanding the problem before validating the solution.
Verifying assumptions.
Contrasting the code against requirements and architecture.
Detecting logical or flow inconsistencies.
Thoroughly testing functionality and potential scenarios.

AI generates code, but the users will be human.

2. Solid Knowledge of Best Practices and Clean Code

A common flaw in AI-generated code is the lack of consistency or failure to apply organizational standards for best practices and quality. AI often generates:

Excessively long methods.
Unnecessarily complex structures.
Ambiguous names.
Duplication.
Poorly organized dependencies.
Code structured without design patterns.

A code supervisor must apply principles such as:

Clean Code.
SOLID.
KISS.
YAGNI.
Design patterns and anti-patterns.
Style standards.
Modern techniques like Hexagonal Architecture or DDD.

Without this conceptual framework, it is impossible to evaluate whether the AI produced something correct or merely something that "works."

3. Software Architecture Knowledge

AI can generate code, but it doesn't design complete systems. It often:

Lacks understanding of context boundaries.
Introduces unnecessary coupling.
Creates structures that don't scale.
Mixes responsibilities.

The supervisor must possess architectural judgment to:

Correct course when the AI makes poor decisions.
Split components appropriately.
Ensure modules adhere to the defined architecture.
Maintain the overall system view.
Consider future functionalities or changes in the architectural design.

Architecture remains human territory, and the AI is merely an assistant within it.

4. Attention to Detail: The Soft Skill That Saves Projects

While AI automates complex tasks, small errors can still have enormous consequences. A mispassed parameter, an inverted conditional, or an unhandled null value can cause failures the AI doesn't detect.
Attention to detail enables the supervisor to:

Review code line-by-line when necessary.
Identify inconsistencies between documentation and code.
Verify input and output data.
Validate names, structures, and contracts.
Perform more robust testing after implementation.

Without this skill, the supervisor becomes just another automatic approver - precisely what we must avoid.

5. Clear Communication and Mastery of Prompt Engineering

The AI code supervisor doesn't just write code: they write instructions. A significant part of the role involves dialoguing with the AI - providing context, correcting its course, and iteratively refining requests. Modern AI tools offer powerful functionalities like execution plans and rules to better guide and set parameters for the desired output.
This demands the ability to:

Express requirements with precision.
Eliminate ambiguity.
Understand how to structure effective prompts.
Request comparisons, alternatives, or in-depth analyses.

Mastering prompts is mastering the true power of AI.

General Recommendations for AI-Generated Code Supervisors

If you are working on a project where code is predominantly AI-generated - using tools like GitHub Copilot, Cursor, or Amazon Q - with rapid delivery cycles, and where AI has become a standard, freely used or even mandatory tool, then your role is already evolving into that of an AI-Generated Code Supervisor.
In these scenarios, certain critical points require your focused attention as a supervisor:

Scrutinize every detail of the generated code. Rewrite prompts as many times as necessary until the output is correct. The prompt is your primary control mechanism.
Test exhaustively and think beyond the "happy path." After implementation, run the code repeatedly. Assume complex, edge-case, and failure scenarios. Do not settle for superficial functionality.
Implement a robust testing strategy. With AI, there is no excuse to skip tests. Implement unit tests, integration tests, and automated testing suites. Let the AI help you generate them, but you must define the scope and validate the results.
Enforce code quality and cleanliness. Eliminate warnings, use static code analysis tools (linters), and maintain clean, well-documented code. The speed of AI generation makes this discipline more crucial, not less.
Invest the time saved by AI into elevating project standards. Use the gained efficiency to keep projects meticulously updated, documented, and maintained with high testing standards. Moving from writing code to curating and guaranteeing a quality codebase.
Leverage all available tools to improve AI context. Create examples, define custom rules and instructions, and build a library of effective, reusable prompts. Treat your interaction with the AI as a high-leverage engineering task.

AI does not eliminate the developer; it elevates them to a more strategic level and transforms how they execute their tasks. However, this new paradigm demands that we strengthen our analytical skills and critical judgment more than ever.
The professionals who cultivate these supervisory skills will become the most valuable assets in the new era of AI-powered software development.

Automating Code Reviews with Junie by JetBrains

Miguel Teheran — Tue, 21 Oct 2025 02:22:45 +0000

Junie is a new power and advanced artificial intelligence (AI) that helps the developers to create, review and analyze code to improve the quality and avoid common issues that sometimes we cannot see during the development process.

Junie is integrated in all the IDEs offered by JetBrains for this demo. We will use Rider and also a C# code related to a simple api that uses the minimal api template provided by dotnet.

I created a new branch and I commited some changes that include bad practices and issues. Here is the list of issues:

Hardcode id used for testing proposal

id = 1; //testing with item 1

bad formatted code (this code looks like Python)

if (region is null)
{
     return

       Results.NotFound();
}

Some unuseful or innecesary conditions:

if (!isValidSort)
{
   if (region is not null)
   {
       if (db is not null)
       {
         return Results.BadRequest(RequestMessages.BadRequest);
       }
    }
}

A hardcoded value is embedded within a query. Sometimes this is valid but not for this case because it refers to the Id.

var region = await db.Regions.Include(p => p.Departments)
                    .SingleOrDefaultAsync(p => p.Id == 0);

After addressing these issues, we can use Junie to review our code and identify any problems before creating a pull request and moving forward with the changes. This is how Junie looks in Rider when you have a project open:

In the chat we need to write the prompt depending on what we want to do with the code. To perform a codereview of the git changes in the branch this is a possible prompt:

Execute an in-depth code review of the current branch, analyzing all committed changes. Generate a document summarizing your findings and ensure to incorporate every recommendation into the code.

Junie will perform some commands in order to complete the instructions requested in the promtp.

After completing all the steps planned by Junie we have now the changes applied in the code and we can see how effective the code review

The hardcoded ID and improperly formatted code have been identified:

Junie identified unnecessary conditions, a hardcoded ID in the query, typos in the department variable, and an issue in the produces function where it's returning department instead of regions.

In conclusion, Junie proves to be an exceptional tool for conducting code reviews. I am truly impressed by its ability to not only identify newly introduced issues but also to catch additional changes made in previous commits around the same code.

We can highlight some advantages of using Junie in our local environment to perform the code review:

We can detect additional changes or issues code analyzing our changes but also all the code around
We can save time and resources by opting to perform the whole code review in the pull request.
We can generate additional code like documentation and relese notes, creating a prompt with more details and steps.

I suggest taking time and working with this AI for some weeks so you can see the potential of this tool.

From Programmer to AI Code Supervisor

Miguel Teheran — Fri, 10 Oct 2025 20:24:38 +0000

A couple of years ago, mentioning Generative AI in software companies led to skepticism and strict security measures. IT departments viewed tools like ChatGPT and GitHub Copilot as potential sources of intellectual property leaks and significant risks. Corporate policies were explicit: “prohibited or strictly regulated usage.” The vast majority of programmers used artificial intelligence (AI) at their own risk and without official permission.

But industry standards changed in the blink of an eye. What was once a threat has now become the standard. The question is no longer “Should we use AI?” but “How can we integrate it more efficiently?” Some companies are now measuring developer productivity based on their adoption and effective use of tools. We have moved from prohibition to a tacit obligation.

The evidence of this change is everywhere, and we developers have witnessed it. Recent studies and surveys paint a clear picture:

GitHub Survey (October 2024): Revealed that 99% of developers in the United States already use AI tools in their workflows. GitHub Copilot, its flagship tool, claims to be responsible for generating up to 40% of the code in supported languages.
JetBrains Survey (Developer Survey 2024): Corroborates this trend, indicating that over 70% of developers have incorporated AI into their processes, primarily for autocompletion, code generation, and error detection. This has given rise to a flourishing ecosystem of tools. From Copilot and Amazon CodeWhisperer to specialized courses teaching “Prompt Engineering for Developers” and mandatory ongoing training within companies. The critical skill is no longer just knowing how to program, but knowing how to orchestrate AI to program for you or alongside you.

My Experience: The Project Where AI Writes the Code (And Everything Else)

My current project has demonstrated the shift in software roles during a legacy migration from Java to C#. This is not a traditional migration project; it is a laboratory of extreme automation based on artificial intelligence where our role as programmers has been radically redefined.

These are the steps we have followed, working hand-in-hand with AI:

Ticket and Documentation Generation: User stories are no longer written manually. An AI prompt analyzes the legacy Java code and automatically generates the ticket description, acceptance criteria, and necessary technical documentation.
C# Code Generation: The core of the process. We use advanced prompts and AI tools to automatically translate Java functions and classes into C#. Our task is not to write code from scratch, but to provide the precise context.
Unit Test Creation: After coding and verifying its functionality, you can easily create unit tests with a simple prompt in Copilot.
Automated Code Review: The code review process is also AI-assisted. A tool handles static analysis, checks patterns, suggests improvements, and detects obvious inconsistencies before a human peer reviews it. All of this happens in the pull request, where feedback is provided through comments on the code lines.
Validation via Automated Testing: The method for testing the fidelity of the migration is very simple. Automated tests are run, feeding the same data into both systems (the legacy Java and the new C#), and the results are compared. If they match, the migrated code is correct.

In this ecosystem, my primary function has ceased to be “programming.” I have become a supervisor of AI-generated code. My value lies in:

Designing the right prompts to get the desired output.
Understanding the business context to validate that the AI has not made a conceptual error.
Making high-level architectural decisions that the AI is not yet capable of assuming.
Keeping constant communication with the client to avoid migrating outdated components and to enhance the code during the migration.

Conclusion and Reflection:

This new role of “supervisor” is incredibly efficient and undoubtedly marks the future of our craft. However, an uncomfortable and inevitable question arises: Along the way, are we beginning to lose the analytical capacity and programming logic that has always characterized us?

The dependence on AI for routine tasks frees us to think about more complex problems. But what about the junior developer who no longer needs to struggle for hours with a loop or a data structure because the AI provides it instantly? Are they missing the opportunity to forge their intuition and mental ability for problem-solving?

Programming was never just about the final code; it was about the thought process, the methodical decomposition of a problem, the teamwork to build code from ideas, and the creative search for a solution. If we outsource that thought process to an AI, we risk becoming technicians who only know how to push the right button, without truly understanding the machinery underneath.

The challenge for the new generation of developers (and for those of us in this transition) will be to find the balance. We must embrace the power of AI without failing to actively cultivate our skills in logical thinking, deep analysis, and creative problem-solving. There is no near-future scenario where AI has total control over a project and human intervention becomes unnecessary. We build software with AI for use by human beings, and as long as this continues, our role as programmers will remain relevant. Maintaining analysis skills and logic is not optional; detecting AI errors as code supervisors will be a necessary skill for competitiveness in the technology fields in the near future.

Full-Stack Developer, myth or reality?

Miguel Teheran — Thu, 03 Oct 2024 13:51:51 +0000

In the past decade, the term "Full-Stack developer" has become popular, referring to a programmer skilled in handling all aspects of modern web projects. Full-Stack developers are experts in front-end and back-end development, covering both the user interface and the server side. Their ability to work in both areas gives them a complete view of projects and improves communication between teams. A major challenge they face is the rapid evolution of technology, which demands ongoing learning to stay updated with the latest tools and frameworks. The requirement to master various technologies, patterns, architectures and trends raises questions about the feasibility of having professionals who meet all these characteristics. It is important to note that a more comprehensive approach is now being considered when defining Full-Stack profiles, incorporating skills such as cloud service management, the use of DevOps tools and the integration of artificial intelligence services.

History

Developers have always had to adapt to new technologies and learn different tools to create robust applications. User interface design used to be mainly performed in IDEs like Visual Studio, Dreamweaver, and NetBeans. These interfaces were much simpler and outdated, while developers focused their attention on optimizing workflows and business logic. The evolution of Web 2.0, coupled with the introduction of HTML5 and innovative JavaScript libraries like Ember.js, Angular.js, and Backbone.js, has greatly expanded the possibilities for front-end development. As a result, the demand for programmers skilled in these technologies has surged, becoming a prominent trend in the industry. By that time, a large number of startups were started (Airbnb, Uber, Spotify) that with their success demonstrated the importance of improving the experience for users and creating technology-based businesses.
Those changes in the industry have led to a requirement for more comprehensive profiles due to project dynamics and budget considerations. A more versatile developer can potentially lower costs associated with hiring multiple programmers and can facilitate the quicker implementation of new features, highlighting the significance of the Full-Stack profile. Something to highlight is that the release of Node.js significantly increased the search for this profile, since using the same programming language (JavaScript) on the front-end and back-end side would theoretically facilitate acquiring the necessary skills to work on both sides of the architecture of an application.

A great back-end is a bad front-end or vice-versa

Many believe that Full-Stack developers excel in one area of development but struggle in another. This isn't due to a rule but rather the difficulty of mastering all the necessary technical skills. For example, a very strong developer on the front-end side with knowledge of architecture and user experience can hardly be an expert in cloud-focused microservices architecture patterns. This is not an impossibility, but considering the advanced technical knowledge needed it is very difficult to achieve.

Personal conclusion based on my professional career

I've worked with many skilled professionals and developers, but I've never seen anyone excel equally at both front-end and back-end development. Typically, their expertise in development or specific technologies is shaped by the challenges they've faced in projects and their personal interests. I believe that the Full-Stack profile can be effective in certain situations, even if it's a controversial opinion.

Some companies implement a design system to build their interfaces based on an architecture with reusable controls and components that facilitate front-end development. They also build all the business logic in the back-end and use ORMs (Object-relational mapping) to control changes and connection to the database. This creates a convenient scenario for a Full-Stack profile where you can make back-end and front-end changes in the same user story (branch, pull request, etc...) and finish developments faster. This is a risk that can affect the quality of development, especially on the front-end side, but it is surely a risk that many companies are willing to take for the benefits it brings.

Another very common scenario in recent years are applications focused on cloud services or based on artificial intelligence services, which means that the complexity of the back-end is reduced and development is focused on the user experience and adaptability of the apps.

The concept of Full-stack development remains debated within the developer community, but it is a highly sought-after skill in the industry. Having expertise in both web and backend development provides a better understanding of software projects and opens up more job opportunities. Everything indicates that we will always be stronger on one of the sides of software development or in some technology, but today having artificial intelligence tools and solid programming bases as a help we can solve complex challenges in every aspect and phase of the development of an application.

dotnet LATAM Day 2024

Miguel Teheran — Tue, 10 Sep 2024 22:09:17 +0000

¡Estás invitad@ al Dotnet LATAM Day!

Únete a nosotros en un evento imperdible donde exploraremos lo mejor de las tecnologías Microsoft. Descubre librerías, productos y servicios innovadores creados con Blazor, .NET, ASP.NET, Azure y otras tecnologías Microsoft. Este es el lugar perfecto para adquirir conocimientos, encontrar inspiración y conectarte con otros apasionados del desarrollo en un evento online completamente gratuito.

¿Cuándo? 24 de octubre 2024 – 2PM GTM-5, bogotá, quito,

¿Dónde? Será transmitido por los canales de Youtube de mteheran.dev y elcamino.dev:

Mteheran.dev – Youtube

El Camino Dev – YouTube

Call for Speakers abierto hasta el 4 de octubre:
Call for speakers (hasta el 4 de octubre): Envía tu charla

Prepárate para un día lleno de charlas, talleres y oportunidades de networking. ¡No te lo pierdas!

Suscribete a nuestros canales de Youtube y asegura tu lugar en el Dotnet LATAM Day.

¡Te esperamos!

Free Books for Flutter Developers

Miguel Teheran — Tue, 13 Feb 2024 16:45:34 +0000

This is a list of books to learn flutter for free:

Flutter Succinctly

Flutter is an open-source mobile application development SDK developed by Google with support for both Android and iOS using the same codebase. Written in C, C++, and Dart, and using the Skia Graphics Engine, Flutter also offers a rich set of fully customizable widgets for building native interfaces, including the Material Design library and Cupertino (iOS-flavored) widgets, rich motion APIs, and hot reload. In Flutter Succinctly, Ed Freitas will take you through creating a fully functional app to help you assess whether Flutter is the right choice for your mobile development needs

https://www.syncfusion.com/succinctly-free-ebooks/flutter-succinctly

Flutter UI Succinctly

Flutter made quite the impact when it landed in the cross-platform mobile framework landscape. Developed by Google, open source, targeting iOS and Android, smooth animations and motion, platform awareness, hot reload—the list of highlights goes on and on, demonstrating why Flutter is a worth any mobile developer’s attention. In Flutter UI Succinctly, Ed Freitas explores the essentials of constructing user interfaces with Flutter, showing off how a handful of Flutter’s built-in widgets and tools can serve as a springboard to creating apps with impressive interfaces.

https://www.syncfusion.com/succinctly-free-ebooks/flutter-ui-succinctly

Flutter Tutorials

This tutorial walks through the basics of Flutter framework, installation of Flutter SDK,
setting up Android Studio to develop Flutter based application, architecture of Flutter
framework and developing all type of mobile applications using Flutter framework.

https://www.tutorialspoint.com/flutter/flutter_tutorial.pdf

Flutter Libraries We Love

We focused on 11 different Flutter library categories. After selecting the categories,
we made a list of libraries under each category and chose the libraries we wanted to
highlight the most.

https://blog.codemagic.io/flutter-libraries-ebook-by-codemagic/ebook-flutter-libraries-we-love-by-codemagic.pdf

How to read zip files with SharpZip library in C#

Miguel Teheran — Fri, 09 Feb 2024 17:52:41 +0000

SharpZip library is a great library to work with compressed files like .zip. This library supports Zip, GZip, BZip2, and Tar.

To use this library, add it to your project using the package manager in Visual Studio or with the following command.

dotnet add package SharpZipLib --version 1.4.2

First, we need to add the following namespace to the project.

using ICSharpCode.SharpZipLib.Zip;

Then to read the file, we need to define the path; it could be a relative or absolute route.

var myZipPath = "test.zip";

With this simple code snippet, we can loop through all the files in the zip and read their content.

using (ZipFile zipFile = new ZipFile(myZipPath))
{
    foreach(ZipEntry zip in zipFile)
    {
        Console.WriteLine(zip.Name);
        using (StreamReader reader = new StreamReader(zipFile.GetInputStream(zip)))
        {
            Console.WriteLine($"Content: {reader.ReadToEnd()}");
            reader.Close();
        }
    }
}

You can also check if the ZipEntry value is a folder or a file to avoid issues reading the information. We have a simple condition. We can validate it.

using (ZipFile zipFile = new ZipFile(myZipPath))
{
    foreach(ZipEntry zip in zipFile)
    {
        if(!zip.IsDirectory)
        {
            Console.WriteLine(zip.Name);
            using (StreamReader reader = new StreamReader(zipFile.GetInputStream(zip)))
            {
                Console.WriteLine($"Content: {reader.ReadToEnd()}");
                reader.Close();
            }
        }
    }
}

Comparison of Automation Frameworks: Selenium, Playwright and Cypress

Miguel Teheran — Thu, 01 Feb 2024 20:10:21 +0000

In modern software development, test automation has become an indispensable element, enabling QA teams and developers to efficiently and effectively verify the quality of their applications. Several tools have emerged to facilitate this process, such as Playwright, Selenium, and Cypress being some prominent options. This comparison will analyze and contrast the three leading tools in test automation, showcasing their strengths, weaknesses, and distinctive features.

Selenium: Widely used, it supports multiple languages and browsers, ideal for end-to-end testing.

Cypress: Modern approach, designed for in-browser testing, stands out for its simplicity, speed and efficiency in integration and unit testing.

Playwright: It is versatile, allowing the automation of advanced tasks, such as emulation of mobile devices. It stands out for its ability to work in multiple browsers and run test in parallel.

General information

In the following table you will learn the general information for each framework:

	Selenium	Playwright	Cypress
Release year	2004	2020	2017
Developer	Jason Huggins -Community	Microsoft	Cypress - Community
License	OpenSource	OpenSource	OpenSource-Cloud license
Written in	Java	TypeScript	JavaScript

Selenium is the oldest and still widely used framework/library for Automation. Playwright, on the other hand, is the newest framework, but their popularity is increasing quickly in the community. Microsoft created Playwright to address common challenges in Selenium, as well as improve integration with DevOps tools and cloud services.

	Selenium	Playwright	Cypress
Languages	JavaScript, Java, Ruby, others	JavaScript, Java, C#, Python	JavaScript only
Browser supported	Almost all of them	Chromium, Firefox, Webkit	Chromium, Firefox, Webkit, Electron
Type	Library	Framework	Framework
Execution time	Fast	Very Fast	Slow
UI extension	No	Yes	Yes

The main feature in Playwright is the performance and support for modern programming languages and frameworks. Selenium has the best support for old browsers and programming languages. Cypress has only support for the JavaScript ecosystem.

Popularity

Let's review the popularity and numbers of downloads in npm. Check the following picture:

In the last months, Playwright has overcome selenium in the number of downloads, stars and contributors on GitHub. This means a great appreciation by the community to this framework.

Selenium is widely regarded as the top choice for Java and Python due to its extensive implementation in major projects over many years.

Demos

In the following sections, we will reproduce the first steps to create our first automation test for these 3 technologies.

For these demos we will use the following web page: https://www.saucedemo.com/

The idea is to perform the login and validate that it was successful on the following screen:

Cypress

Let's review the prerequisites and commands to create our first test in Cypress.

Prerequirements

Node.js 18 or 20

Steps:

Go to an empty folder where you want to create the project
Execute npm install cypress --save-dev
Then use this command to execute the project: npx cypress open
Now in the folder cypress/e2e create a new test with the name spec.cy.js
Add the following code to create a new test for the login.

describe('Sauce demo', () => {
  it('login pass', () => {
    cy.visit('https://www.saucedemo.com/#/')
    cy.get('#user-name').type('standard_user')
    cy.get('#password').type('secret_sauce')
    cy.get('#login-button').click()
    cy.get('.app_logo').should('have.text', 'Swag Labs')
  })
})

In cypress, we type cy to use the API and call the functions to detect elements, set values and navigate in the page. The code is petty simple and easy to understand. We use #element-id cal get elements by Id and .class to get the element by CSS class. We don't need to install extra libraries or components to create our first tests.

Selenium

Let's review the prerequisites and commands to create our first test in Selenium with JavaScript.

Prerequirements

Node.js 18 or 20

Steps:

Go to an empty folder where you want to create the project
Execute the following commands:

npm install selenium-webdriver

npm install chromedriver

npm install mocha

NOTE: selenium-webdriver is used to interact with the browser, chromedriver is used to execute the test in chrome so Selenium can control it and mocha help us to create the test like a simple unit test and capture the result.

Create a file test.js where the test will be located
Add the following code to perform the test on the login page with Selenium:

const Chrome = require('selenium-webdriver/chrome');
const {By, Builder} = require('selenium-webdriver');
const assert = require("assert");
const options = new Chrome.Options();
const {suite} = require('selenium-webdriver/testing');


suite(function (env) {
    describe('Should be able to Test Command line arguments', function () {
      it('headless', async function () {
    let driver;

    driver = await new Builder()
            .setChromeOptions()
            .forBrowser('chrome').build();
    await driver.get('https://www.saucedemo.com/');
    await driver.manage().setTimeouts({implicit: 500});
    await driver.findElement(By.id('user-name')).sendKeys('standard_user');
    await driver.findElement(By.id('password')).sendKeys('secret_sauce');
    await driver.findElement(By.id('login-button')).click();
    var textLogo = await driver.findElement(By.className('app_logo')).getText();
    assert.equal('Swag Labs', textLogo);
    await driver.quit();
});
});
});

Selenium has a better experience in other programming languages, like Java, Python and C#. Since Selenium is a library, we need to install other libraries to complement it. And install the drivers to connect with the browser where we want to run the test.

Playwright

Let's review the prerequisites and commands needed to create our first test in Playwright with JavaScript.

Prerequirements

Node.js 18 or 20

Steps:

Go to an empty folder where you want to create the project
Run npm init playwright@latest to create the base project
Then use this command to execute the tests: npx playwright test
Create a new file mytest.spec.js in the folder tests
Add the following code to test the login page using Playwright:

const { test, expect } = require('@playwright/test');

test('Login pass', async ({ page }) => {
  await page.goto('https://www.saucedemo.com/');
  await page.locator("#user-name").fill("standard_user");
  await page.locator("#password").fill("secret_sauce");
  await page.locator('#login-button').click();

  // Expect a title "to contain" a substring.
  await expect(await page.locator('.app_logo')).toHaveText('Swag Labs')
});

In playwright, we use the word page to interact with the browser. We can also use the method .toHaveText to validate the result and create assertions. Playwright is not only incredibly user-friendly for developers, but it also boasts a seamless functionality that requires no additional dependencies or extra libraries in order to work perfectly in a variety of scenarios.

Developer Experience

JavaScript's developers find Cypress easy to understand because the tests are similar to unit tests in JavaScript with libraries like jest. Cypress may be limiting and restrictive for automation QA professionals who prefer to have full control over their workflow and do not rely on the UI for test inspection and execution. Cypress only works with JavaScript, so it's hard to compare it with Playwright, which is popular among other developers.
Selenium has a high flexibility and I can combine it with my favorite libraries. Once the project is established, we can enhance the test structure, streamline the main framework, and optimize code reuse. This approach is favored by many developers.

UltimateQA posted a survey about the user experience for these frameworks. Ultimate QA survey

The results seem inaccurate because Cypress and Playwright are incredibly user-friendly, yet Selenium remains the most widely used automation library and many developers only have familiarity with it.

Possible Scenarios vs Best Option

Let's analyze some common scenarios and which framework is a better fit.

A modern application with a small team that uses a new Javascript framework (React.js, Angular, etc..). The team doesn't have experience with automation testing. For this scenario, the best option could be Cypress or Playwright. Developers can easily work with the UI provided for these frameworks and work with JavaScript.
An app with a modern backend (Node.js, Python, C#, etc.) and modern frontend (React.js, Angular, etc.) with a big team.
For this scenario, we can use all the 3 options. But to work with something modern Playwright could be the best one. We can work with different languages according to the team knowledge and Playwright has been adding extensibility with Selenium.
A desktop application using Electron (JavaScript) with node.js backend. In this case, all these frameworks are bad options. At the moment, both Playwright and Cypress offer experimental plugins or extensions for electron, but they may not be suitable for production purposes. We can use Spectron, WebDriverIO or Selenium in conjunction with other libraries to perform our tests.

Conclusions

In modern software development, the main test automation tools are Selenium, Cypress, and Playwright. Each of these tools offers unique strengths and weaknesses, catering to different needs within the software testing landscape.

Selenium, as the oldest and widely used framework, excels in supporting multiple languages and browsers, making it ideal for end-to-end testing. Cypress, with its modern approach, stands out for in-browser testing, simplicity, and efficiency in integration and unit testing. Playwright is a versatile automation tool that excels in multiple browser support, parallel test execution, and automating advanced tasks like mobile device emulation.

The popularity metrics, including downloads, stars, and contributors on GitHub, depict Playwright's recent surge, surpassing Selenium in community appreciation. However, Selenium remains a top choice for many teams.

Ultimately, the choice of test automation tool depends on project requirements, team expertise, and the application being tested.

In my opinion, Playwright will continue growing, and it is a modern and fast tool. I see a great projection for Playwright in the future.

If you want to try the demos and access the repo, click on the following link:
https://github.com/Mteheran/AutomationDemos

Discussion: What are the best alternative cloud providers?

Miguel Teheran — Wed, 24 Jan 2024 21:49:22 +0000

It's clear that AWS, Azure and GCP are the most used and popular cloud providers around the world. We can add Alibaba Cloud to this list because they have a high demand in the market.

I know some other options less popular that we can use for some scenarios:

Cloudinary: Used for video and image (media content)
Oracle Cloud: Databases and storage
Netlify: Web services and applications
IBM Cloud: Compute, integration and storage

What of these alternative cloud providers do you use?
What other cloud providers do you know, and how was your experience?

Adding Branch Name To The Commit Message In Git Using Hooks

Miguel Teheran — Tue, 16 Jan 2024 17:25:10 +0000

Git Hooks is an amazing tool to automate actions before or after executing a git command. Some common scenarios where we can use hooks are:

Validate the format (using eslint for example) before a commit
Validate the commit message format
Update a version of a file or settings
Add a default text in the commit message

In this article, we will learn how to add as a default text the branch name in the commit message. Creating a new branch for each new story and naming it after the associated ticket or story number is crucial for maintaining a well-organized and structured development process. This way, you can do things like automatically move the ticket to "doing" status when the branch is created or create a link between the user story and each commit in the branch.

Some examples of user story numbers in Jira or other bug trackers are:

U-0001
COMP-0001
STORY-001

To create our hook for adding the branch name in the commit message we need to navigate to the hooks' folder in our projects.

Navigate to your folder's project and open .git folder and then hooks folder. There you will find some default templates to create your own hook.

Example on macOS:

Now you have to create a file with the name prepare-commit-msg. Prepare commit message is the action executed before setting the message in the commit.

Within prepare-commit-msg file you need to add the following code:

# prepending commit message.
if [ -z "$BRANCHES_TO_SKIP" ]; then
  BRANCHES_TO_SKIP=(master develop release)
fi

BRANCH_NAME=$(git symbolic-ref --short HEAD)
BRANCH_NAME="${BRANCH_NAME##*/}"

BRANCH_EXCLUDED=$(printf "%s\n" "${BRANCHES_TO_SKIP[@]}" | grep -c "^$BRANCH_NAME$")
BRANCH_IN_COMMIT=$(grep -c "\[$BRANCH_NAME\]" $1)

if [ -n "$BRANCH_NAME" ] && ! [[ $BRANCH_EXCLUDED -eq 1 ]] && ! [[ $BRANCH_IN_COMMIT -ge 1 ]]; then
  sed -i.bak -e "1s/^/$BRANCH_NAME - /" $1
fi
Bash

In line number 13 (sed -i.bak -e "1s/^/$BRANCH_NAME - /" $1), you can see how the branch name is set. You can add more default text or words after the branch name. In this case, we only have a dash.

By utilizing this configuration, all you have to do is input your message, and it will automatically include the branch name at the start of the commit message.