DEV Community: Sergio Triana Escobedo

Introducing UniquePtr: A Powerful Smart Pointer for Rust Developers

Sergio Triana Escobedo — Wed, 12 Jul 2023 17:06:38 +0000

Are you a Rust developer seeking a robust and efficient solution for managing dynamically allocated objects? Look no further! We're excited to introduce UniquePtr, a simple yet powerful smart pointer library for Rust. With UniquePtr, you can achieve unique ownership semantics, ensuring proper deallocation of objects and freeing you from the burden of manual memory management.

Why UniquePtr?

Rust's ownership system already provides excellent memory safety guarantees. However, there are cases where you still need precise control over object lifetimes, especially when working with dynamically allocated memory. UniquePtr fills this gap by offering a straightforward and idiomatic way to handle unique ownership scenarios. Here's why you should consider using UniquePtr:

Automatic Deallocation

With UniquePtr, you can say goodbye to memory leaks and dangling pointers. It automatically deallocates the managed object when it goes out of scope. You no longer need to manually track and free memory, saving you valuable time and effort.

Unique Ownership

UniquePtr enforces exclusive ownership of objects. Only one UniquePtr instance can own and manage the object at any given time. This eliminates the risks associated with multiple owners and ensures predictable and safe memory management.

Customizable Deletion

UniquePtr allows you to customize the deallocation behavior by specifying a custom deleter. Whether you need to invoke a specific function or perform additional cleanup operations, UniquePtr's flexible design enables you to tailor the deletion process to your specific requirements.

Seamless Integration

UniquePtr integrates seamlessly with Rust's ownership model. It works harmoniously with Rust's borrow checker and error handling mechanisms, providing a cohesive and intuitive experience. You can leverage the full power of Rust's language features while enjoying the benefits of smart pointer semantics.

Getting Started with UniquePtr

Using UniquePtr is straightforward. Simply add the UniquePtr dependency to your Cargo.toml file:

[dependencies]
unique_ptr = "0.1.0"

Then, import the UniquePtr type into your code:

use unique_ptr::UniquePtr;

Once imported, you can create and manipulate UniquePtr instances just like any other Rust type. Take advantage of the provided methods for resetting the pointer, releasing ownership, cloning, and dereferencing.

Here's a simple example:

use unique_ptr::UniquePtr;

fn main() {
    let ptr = Box::new(42);
    let unique_ptr = UniquePtr::with_ptr(ptr);

    assert_eq!(unsafe { *unique_ptr.ptr }, 42);

    let ptr2 = Box::new(99);
    unique_ptr.reset(ptr2);

    assert_eq!(unsafe { *unique_ptr.ptr }, 99);
}

Contributing and Support

If you encounter any issues, have ideas for enhancements, or wish to contribute code, feel free to open an issue or submit a pull request on our GitHub repository.

Conclusion

UniquePtr empowers Rust developers with a reliable solution for managing dynamically allocated objects. By providing automatic deallocation and unique ownership semantics, UniquePtr enhances the safety and efficiency of your code. Say goodbye to memory leaks and embrace the simplicity of smart pointers.

apppass

Sergio Triana Escobedo — Wed, 05 Jul 2023 02:49:07 +0000

In the world of software development, security is of paramount importance. Generating strong passwords is a common need for developers and users alike. If you're a programmer looking for a reliable and convenient way to generate secure passwords for your applications, look no further than apppass. This command-line application, written in Rust, offers a simple yet powerful solution to address this requirement.

What is apppass?

apppass is an amazing command-line application built with Rust. It empowers developers and users to generate highly secure passwords for their applications. With apppass, you can store these passwords in a secure registry, accessible directly from the command line interface (CLI) using intuitive commands.

Getting Started

If you don't have Rust installed on your machine, fret not! You can easily download the latest release of apppass from the repository. This ensures that you can quickly get started without worrying about the installation process.

For those who already have Rust installed, you can leverage Cargo, Rust's package manager, to obtain and utilize apppass effortlessly. Simply run the following command to install apppass:

$ cargo install apppass

Once you have apppass installed, generating passwords is a breeze. Let's say you want to create a password for your Gmail application. Simply execute the following command:

$ ./apppass --app gmail or ./apppass -a gmail
Password generated and saved for the application: gmail

After generating the password, apppass will automatically save it for the specified application, in this case, gmail. You'll receive a confirmation message indicating that the password has been successfully stored.

Upon executing this command, apppass will display the application name (gmail) and its corresponding password, providing you with the necessary information you need.

$ ./apppass --get gmail or ./apppass -g gmail
Application_Name: gmail
Password: aB1nwWQyyu2rts7xc3vh90hGk0amlt

If you have multiple applications registered with apppass, you can easily list them using the following command:

This command will display a list of the registered applications along with their respective passwords, allowing you to keep track of your credentials efficiently.

$ ./apppass --list or ./apppass -l
Application_Name: github_credential
Password: JsHx7YX4jAaH4L54uBKoNbuHd59ABO

Application_Name: gmail
Password: aB1nwWQyyu2rts7xc3vh90hGk0amlt

Conclusion:

apppass is a remarkable Rust-based command-line application that simplifies the process of generating secure passwords for your applications. With its user-friendly interface and secure password storage capabilities, apppass offers a convenient solution for developers and users seeking robust password management. By leveraging the power of Rust, apppass ensures reliability, performance, and the highest standards of security. Give apppass a try today and enhance the security of your applications with ease.

SQL A SMALL GUIDE FOR ENGINEERS

Sergio Triana Escobedo — Thu, 30 Mar 2023 21:37:03 +0000

As software engineers, we work with SQL databases all the time, and we know that there are many ways to get valuable information from them. In this article, we will delve into the most advanced SQL statements and explain how they can help solve complex problems and obtain useful information.

UNION

The UNION statement is used to combine two or more result sets into one. The result sets must have the same column structure. For example, if we want to combine two customer tables, we can use the following syntax:

SELECT name, address FROM customers
UNION
SELECT name, address FROM customers_backup;

This will return a result set with the names and addresses of the customers from both tables, without duplicates.

JOIN

The JOIN statement is used to combine two or more tables into a single query. There are several types of JOIN, including INNER JOIN, LEFT JOIN, RIGHT JOIN, and FULL OUTER JOIN.

For example, if we want to combine a customer table with an order table to get information about each customer's orders, we can use the following syntax:

SELECT customers.name, orders.order_date, orders.total_amount
FROM customers
INNER JOIN orders
ON customers.customer_id = orders.customer_id;

This will return a result set with the name of each customer, the date of each order, and the total amount of each order.

SUBQUERY

A subquery is a query inside another query. Subqueries are often used to filter results or to perform complex calculations.

For example, if we want to find the customers who have placed orders with a total amount greater than the average, we can use the following syntax:

SELECT name, address
FROM customers
WHERE customer_id IN (
  SELECT customer_id
  FROM orders
  GROUP BY customer_id
  HAVING SUM(total_amount) > (
    SELECT AVG(total_amount)
    FROM orders
  )
);

This query will return the names and addresses of the customers who have placed orders with a total amount greater than the average of all orders.

WINDOW FUNCTION

A window function is a function that performs calculations on a set of rows related to the current row. Window functions are often used for statistical and aggregate calculations.

For example, if we want to find the rank of each customer based on the total amount of their orders, we can use the following syntax:

SELECT name, total_amount,
  RANK() OVER (ORDER BY total_amount DESC) as ranking
FROM (
  SELECT customers.name, SUM(orders.total_amount) as total_amount
  FROM customers
  INNER JOIN orders
  ON customers.customer_id = orders.customer_id
  GROUP BY customers.customer_id
) as customer_totals;

This query will return the names of the customers, the total amount of their orders, and their ranking based on that total amount.

LIKE

The LIKE clause is used in SQL to search for text patterns in a table. For example, suppose we have an employee table and want to find all employees whose name starts with "A". We could use the following query:

SELECT * FROM employees WHERE name LIKE 'A%';

In this example, the % character is used to represent any number of characters that may appear after the "A". Therefore, this query would retrieve all employees whose name begins with "A".

HAVING

The HAVING clause is used in SQL to filter the results of a query based on a condition involving an aggregate function (such as SUM, COUNT, AVG, MAX, or MIN). For example, suppose we have a sales table and want to find all stores whose total sales exceed $100,000. We could use the following query:

SELECT shop, SUM(salesforce) as total_salesforce FROM salesforce GROUP BY shop HAVING SUM(salesforce) > 100000;

In this example, the SUM aggregation function is used to calculate total sales for each store, and then the results are filtered using the HAVING clause to show only stores whose total sales exceed $100,000.

INDEX

An index is a data structure used to speed up queries in a table. An index is created on one or more columns of the table and allows the database engine to search data faster. For example, if we have an employee table with a name column and want to search for all employees whose name starts with "A", we could create an index on the name column to speed up the search. The syntax for creating an index in SQL is as follows:

CREATE INDEX index_names ON employees (name);

In this example, we are creating an index called "index_names" on the "employees" table on the "name" column.

TRIGGERS

Triggers are database objects that are automatically executed in response to certain events in the table. For example, we could create a trigger that is automatically executed every time a new row is inserted into a table. The trigger could perform some action, such as updating another table or sending an email. The syntax for creating a trigger in SQL is as follows:

CREATE TRIGGER trigger_name BEFORE INSERT ON table FOR EACH ROW BEGIN ... END;

In this example, we are creating a trigger called "trigger_name" that will be executed before a new row is inserted into the "table". The trigger will be executed once for each inserted row and the logic will be defined within the BEGIN...END block.

CONCLUSION

In conclusion, SQL statements are very useful for solving problems and obtaining useful information from databases. In this article, we have explored some of the most useful statements such as UNION, JOIN, SUBQUERY, WINDOW FUNCTION, LIKE, HAVING, INDEX, and TRIGGERS which are important aspects of SQL that allow users to interact with data efficiently. I hope this guide has been helpful to everyone.

HAPPY CODING!!!

What is a Reverse Proxy and its Utility?

Sergio Triana Escobedo — Wed, 29 Mar 2023 23:17:35 +0000

A reverse proxy is a type of server that acts as an intermediary between a client and one or more destination servers. Unlike a normal proxy, which acts as an intermediary between a client and an origin server, a reverse proxy is used to hide the identity and location of the destination servers.

The utility of a reverse proxy lies in its ability to provide an additional layer of security and privacy by hiding the real location of the destination servers behind a single public IP address. Additionally, a reverse proxy can also improve website performance by caching static content such as images and CSS files.

Here are some examples of how to use a reverse proxy in Python3:

Using Flask:

from flask import Flask, render_template
import requests

app = Flask(__name__)

@app.route('/')
def home():
    r = requests.get('http://example.com')
    return r.content

if __name__ == '__main__':
    app.run(port=5000)

In this example, we're using Flask to create a simple web server that listens on port 5000. When a user navigates to the home page, the server sends a GET request to http://example.com and returns the content of the response.

Using aiohttp

import aiohttp
import asyncio

async def get_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def home(request):
    data = await get_data('http://example.com')
    return web.Response(text=data)

app = web.Application()
app.add_routes([web.get('/', home)])

if __name__ == '__main__':
    web.run_app(app, port=5000)

In this example, we're using the aiohttp library to create an asynchronous web server that listens on port 5000. When a user navigates to the home page, the server sends an asynchronous GET request to http://example.com using the get_data function and returns the response as text.

Using reverse_proxy

from http.server import HTTPServer, BaseHTTPRequestHandler
import http.client

class ReverseProxy(BaseHTTPRequestHandler):
    def do_GET(self):
        conn = http.client.HTTPSConnection("example.com")
        conn.request(self.command, self.path)
        resp = conn.getresponse()

        self.send_response(resp.status)
        for header, value in resp.getheaders():
            self.send_header(header, value)
        self.end_headers()

        self.copyfile(resp, self.wfile)

httpd = HTTPServer(('localhost', 5000), ReverseProxy)
httpd.serve_forever()

In this example, we're using the built-in http.server library to create a simple HTTP server that listens on port 5000. When a user navigates to the home page, the server sends a GET request to http://example.com using the ReverseProxy class and returns the response to the client.

In conclusion, a reverse proxy is a powerful tool that can be used to improve the security, privacy, and performance of web servers. In Python3, there are several libraries and frameworks that can be used to create reverse proxies, including Flask, aiohttp, and the built-in http.server library.