Best match

Most recent

Microsoft Windows

How-to

If the drive that fails to initialize is empty or contains no essential data, you should format it. Then, you can create a new partition by converting its format to GPT and assigning the new volume. It is the most recommended method for resolving the issue and has worked for many users. To accomplish that, follow these steps:

Hard disk drive

How to Fix the “Disk Unknown Not Initialized” Issue on Windows

https://www.bing.com/th?id=ODF.ZDmVE7fXNMqQGBsnpiE03A&pid=news

MUO on MSN.com

Lucas Ochoa and Gautam Bose were hired together out of college at Google Creative Lab, Google’s tech and culture incubator, and spent three and a half years launching products like the AI Test K

initialized capital

TechCrunch

Get the most recent info and news about Initialized on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

Initialized

Ending The Crypto Winter with Garry Tan and Brett Gibson of Initialized Capital

In the modern world of , ensuring the confidentiality of passwords and other sensitive data is a paramount concern. For this purpose, cryptographic algorithms and key derivation functions are widely employed. One such algorithm is (Password-Based Key Derivation Function 2), used to derive cryptographic keys from passwords. Let’s delve into how PBKDF2 works using a Java service as an example. information security PBKDF2 What is PBKDF2? PBKDF2 is an algorithm designed to strengthen the security of passwords by creating cryptographic keys for cryptographic operations such as encryption. It achieves this by applying repeated hashing (iterations) to the password and adding a random “ ” to thwart brute-force attacks. salt The Role of Salt Salt is a random value added to the password before hashing and key derivation. Using salt serves several crucial : purposes : Salt ensures that each password’s hash is unique, even if the passwords themselves are identical. This uniqueness makes attacks based on precomputed tables (such as rainbow tables) less effective because the hash for the same password will differ due to different salts. Unique Hashes : Salt makes passwords less susceptible to dictionary attacks. Even if two users have the same password, using different salts results in different hashes. Protection Against Dictionary Attacks : Salt complicates the process of calculating the hash, requiring attackers to expend additional computational resources and time when attempting to crack a password through brute force. Password Security Enhancement Java Service Example Let’s examine a Java service example that utilizes PBKDF2 for encryption and decryption. The code example below represents this service, and we’ll break it down step by step. Constructor In the constructor, the master password ( ) and salt ( ) are initialized. These values will be used to create the encryption key. It's essential to ensure that the length of both the master password and salt meets the minimum security requirements. masterPassword salt public PasswordDerivationService(String masterPassword, String salt) {
    this.masterPassword = masterPassword;
    this.salt = salt;
    validateSaltAndMasterPassword(masterPassword, salt);
} Key Derivation This method creates the key used for encryption and decryption. It employs PBKDF2 to derive the key from the master password and salt. private SecretKeySpec generateSecretKeySpec() throws InvalidKeySpecException, NoSuchAlgorithmException {
    SecretKeyFactory factory = SecretKeyFactory.getInstance(KEY_DERIVATION_ALGORITHM);
    KeySpec spec = new PBEKeySpec(masterPassword.toCharArray(), salt.getBytes(), 512, 256);
    SecretKey tmp = factory.generateSecret(spec);
    return new SecretKeySpec(tmp.getEncoded(), CRYPTO_ALGORITHM);
} Cipher Preparation This method initializes a object for encrypting or decrypting data. It uses the previously created key and encryption parameters, such as the Initialization Vector (IV). Cipher private Cipher prepareCipher(int cipherMode) throws NoSuchPaddingException, NoSuchAlgorithmException,
        InvalidKeySpecException, InvalidAlgorithmParameterException, InvalidKeyException {
    IvParameterSpec ivSpec = new IvParameterSpec(IV);
    Cipher cipher = Cipher.getInstance(CIPHER_TRANSFORMATION);
    cipher.init(cipherMode, generateSecretKeySpec(), ivSpec);
    return cipher;
} Encryption The method uses the initialized cipher to encrypt input data. The encryption result is represented as a Base64-encoded string. encrypt public String encrypt(@Nonnull String dataToEncrypt) {
    try {
        Cipher cipher = prepareCipher(Cipher.ENCRYPT_MODE);
        return Base64.getEncoder().encodeToString(cipher.doFinal(dataToEncrypt.getBytes(StandardCharsets.UTF_8)));
    } catch (Exception e) {
        throw new EncryptionException(e.getMessage(), e);
    }
} Decryption The method employs the initialized cipher to decrypt a string encrypted using the method. It returns the original data. decrypt encrypt public String decrypt(@Nonnull String dataToDecrypt) {
    try {
        Cipher cipher = prepareCipher(Cipher.DECRYPT_MODE);
        return new String(cipher.doFinal(Base64.getDecoder().decode(dataToDecrypt.getBytes(StandardCharsets.UTF_8))));
    } catch (Exception e) {
        throw new DecryptionException(e.getMessage(), e);
    }
} Validate salt & master password The method checks the length of the master password and salt to ensure they meet minimum security requirements. If the lengths do not comply with these requirements, an exception is raised. validateSaltAndMasterPassword protected void validateSaltAndMasterPassword(@Nonnull String masterPassword, @Nonnull String salt) {
    if (masterPassword.length() < MIN_MASTER_PASSWORD_LENGTH) {
        throw new EncryptionException("Master password length must be at least " + MIN_MASTER_PASSWORD_LENGTH);
    }
    if (salt.length() < MIN_SALT_LENGTH) {
        throw new EncryptionException("Salt length must be at least " + MIN_SALT_LENGTH);
    }
} Conclusion The PBKDF2 algorithm is a powerful tool for enhancing the security of passwords and data. Understanding how PBKDF2 works can assist developers in creating secure applications. The Java service example provided demonstrates how PBKDF2 can be used to generate cryptographic keys and ensure secure encryption and decryption of data. This example underscores the importance of correctly implementing cryptography to safeguard data confidentiality and integrity, while also explaining the role of salt in enhancing password security. You can view the full project code on Github

Understanding the PBKDF2 Аlgorithm With a Java Service Example

In this article, I will acquaint you with the notion of Few-shot learning, focusing on the widely-used approach known as SetFit for text classification. To begin our learning journey, we'll start by revisiting Traditional Machine Learning techniques. Afterward, we'll transition into the realm of Few-shot Learning using SetFit for the purpose of text classification on an E-Commerce dataset. Traditional ML In supervised machine learning, a substantial dataset is employed for model training. After completing the training process, we utilize test data to obtain predictions from the model. The model's ability to make precise predictions is honed through extensive training on this large dataset. However, a notable drawback of this conventional supervised learning approach is the necessity for an extensive and error-free training dataset, which may not always be accessible across all domains. Consequently, this has led to the emergence of the concept of few-shot learning. Prior to delving into Sentence Transformer fine-tuning (SetFit), it is essential to briefly revisit a crucial aspect of Natural Language Processing (NLP) known as few-shot learning. Few-shot Learning Few-shot learning involves training a model using limited training datasets, where the model gains knowledge from these small sets referred to as support sets. The key distinction lies in teaching few-shot models to discern both the similarities and differences among the training data. For instance, instead of instructing the model to classify images as cats or dogs, we instruct it to grasp the commonalities and distinctions among various animals. This approach, which focuses on understanding the similarities and distinctions within input data, is commonly referred to as meta-learning or learning-to-learn. Few-shot learning's support set is also referred to as k-way and n-shot learning, where "k" represents the number of classes in the support set. In binary classification, for instance, k equals 2. Additionally, "n" indicates the number of samples available for each class within the support set. For instance, if there are 10 data points for the positive class and 10 for the negative class, n equals 10. In summary, this support set can be described as 2-way and 10-shot learning. Now that we have a fundamental understanding of Few-shot learning, let's explore its practical application through SetFit. SetFit: Sentence Transformer fine-tuning SetFit, an exhilarating open-source tool for few-shot classification, was jointly developed by teams from Hugging Face and Intel Labs. You can find comprehensive information about it in the . project repository Using just 8 labeled examples per class from the Customer Reviews (CR) sentiment dataset, SetFit achieves results on par with fine-tuning RoBERTa Large on the complete training set consisting of three thousand examples. It's worth highlighting that the fine-tuned RoBERTa model is three times larger than the SetFit model utilized in this comparison. Below is the architecture of SetFit. Image source Implementation of Few-shot learning: SetFit SetFit is super fast and efficient to train, with a competitive performance compared to larger models like GPT-3 and T-FEW. The below image shows that SetFit outperforms RoBERTa in few-shot learning. Image source Dataset In this instructional guide, we'll be working with a unique E-Commerce dataset comprising four distinct categories: Books, Clothing & accessories, Electronics, and Household items. The primary objective of this dataset is to categorize product descriptions sourced from E-Commerce websites into these specified labels. To facilitate a few-shot training approach, we will select eight samples from each of the four categories, resulting in a total of 32 training samples. The remaining samples will be reserved for testing purposes. The support set we use here is 4-way and 8-shot learning. A sample of the custom E-Commerce dataset is shown in the below figure, We employ the Sentence Transformers pre-trained model called " " to transform textual data into vector embeddings. This model generates vector embeddings with a dimensionality of 768 for the input text. all-mpnet-base-v2 We will start the Implementation of SetFit by installing the required packages into the conda environment. !pip3 install SetFit
!pip3 install sklearn
!pip3 install transformers
!pip3 install sentence-transformers Having installed the packages, we can now load our dataset. from datasets import load_dataset
dataset = load_dataset('csv', data_files={
"train": 'E_Commerce_Dataset_Train.csv',
"test": 'E_Commerce_Dataset_Test.csv'
}) We will take a look into the number of training and test samples. To convert text labels into encoded labels, we will use LabelEncoder from sklearn package. from sklearn.preprocessing import LabelEncoder 
le = LabelEncoder() With LabelEncoder we will encode both training and testing datasets and add those encoded labels into the “Label“ column of the dataset. Encoded_Product = le.fit_transform(dataset["train"]['Label']) 
dataset["train"] = dataset["train"].remove_columns("Label").add_column("Label", Encoded_Product).cast(dataset["train"].features) Encoded_Product = le.fit_transform(dataset["test"]['Label']) 
dataset["test"] = dataset["test"].remove_columns("Label").add_column("Label", Encoded_Product).cast(dataset["test"].features) Now we will initialise the SetFit model and sentence-transformers model. from setfit import SetFitModel, SetFitTrainer 
from sentence_transformers.losses import CosineSimilarityLoss model_id = "sentence-transformers/all-mpnet-base-v2" 
model = SetFitModel.from_pretrained(model_id) trainer = SetFitTrainer( 
  model=model,
  train_dataset=dataset["train"],
  eval_dataset=dataset["test"],
  loss_class=CosineSimilarityLoss,
  metric="accuracy",
  batch_size=64,
  num_iterations=20,
  num_epochs=2,
  column_mapping={"Text": "text", "Label": "label"}
) Having initialized both models, now we call the training procedure. trainer.train() Once the training is completed for 2 epochs, we will evaluate the trained model on the eval_dataset. trainer.evaluate() Our trained model produced a peak accuracy of 87.5%. While an accuracy of 87.5% might not typically be considered high, it's important to take into account that our model was trained with just 32 samples. Given the limited dataset size, achieving an 87.5% accuracy on the test dataset is actually quite impressive, indicating that the model performs admirably well under these circumstances. SetFit also provides the capability for you to save the trained model to your local storage and subsequently load it from the disk for use in future predictions. trainer.model._save_pretrained(save_directory="SetFit_ECommerce_Output/") model = SetFitModel.from_pretrained("SetFit_ECommerce_Output/", local_files_only=True) To make predictions on new data, input = ["Campus Sutra Men's Sports Jersey T-Shirt Cool-Gear: Our Proprietary Moisture Management technology. Helps to absorb and evaporate sweat quickly. Keeps you Cool & Dry. Ultra-Fresh: Fabrics treated with Ultra-Fresh Antimicrobial Technology. Ultra-Fresh is a trademark of (TRA) Inc, Ontario, Canada. Keeps you odour free."]
output = model(input) The predicted output is 1. The LabelEncoded value for the label is “Clothing $ Accessories“. Therefore, our model demonstrates both accuracy and efficiency in contrast to traditional ML models, which require substantial training resources, including time and data, to become proficient. After perusing this article, I believe you now possess a fundamental grasp of the concept of few-shot learning and how to apply it using SetFit. To gain a more profound comprehension, I strongly advise you to select a practical scenario, create a dataset, write code, and enjoy the learning process. Those who are intrigued may also explore Zero-shot Learning and One-shot Learning. Keep your learning journey going!

Mastering Few-Shot Learning with SetFit for Text Classification

Debugging: The Nature of Bugs, Their Evolution, and Tackling Them More Effectively

Depuración: la naturaleza de los errores, su evolución y cómo abordarlos de forma más eficaz

Débogage : la nature des bogues, leur évolution et leur résolution plus efficace

डिबगिंग: कीड़ों की प्रकृति, उनका विकास, और उनसे अधिक प्रभावी ढंग से निपटना

デバッグ: バグの性質、その進化、およびより効果的に対処する

Depuração: a natureza dos bugs, sua evolução e como lidar com eles de maneira mais eficaz

Gỡ lỗi: Bản chất của lỗi, sự tiến hóa của chúng và cách xử lý chúng hiệu quả hơn

调试：错误的本质、它们的演变以及更有效地解决它们

DevOps has become an integral component in the world of software development for firms trying to simplify their development and deployment processes. Among the several DevOps technologies available, there is one that is sometimes neglected yet is really effective. That vital technology is none other than “ ” . Git Hooks Git Hooks are great tools to automate tasks, enforce coding standards, perform continuous deployments, and run tests. Let us see how we can use Git Hooks to revolutionize our DevOps practices! First Things First… What Are Hooks? Let us look at the official definition first - Hooks are programs you can place in a hooks directory to trigger actions at certain points in git’s execution. Fortunately, that is a really simple definition! Let us try to address some of the questions that readers might have about the definition. Q) What is a Hooks directory? Where is it located? A hooks directory is a directory in a Git repository that contains executable programs or Hooks that Git will execute. By default, the hooks directory is . Users can also configure it using the configuration variable. $GIT_DIR/hooks core.hooksPath Q) What are Git’s execution points? Git execution points are steps in the Git workflow at which hooks can be run. Pre-commit, Post-commit, Pre-push, Post-receive, Pre-rebase, and Post-merge are some examples of Git execution points. To sum up this section, we can have the following definition for Git Hooks - Git executes scripts known as "hooks" before or after particular operations like committing, pushing, or merging code. directory of your Git repository They allow you to automate tasks, enforce policies, and interact with the codebase during the development process. Git hooks are stored in the .git/hooks Creating Our Very First Git Hooks! Let's attempt to build a straightforward Git hook that would impose the "TASK*" regular expression on any commit message. Create a new directory , and initialize a new git repository inside it. git_hooks_tut ~/projects$ mkdir git_hooks_tut
~/projects$ cd git_hooks_tut
~/projects/git_hooks_tut$ git init
Initialized empty Git repository Let us go into the hooks directory and investigate its content. ~/projects/git_hooks_tut$ cd .git/hooks
~/projects/git_hooks_tut/.git/hooks$ ls
applypatch-msg.sample	   pre-applypatch.sample      pre-push.sample
commit-msg.sample	   pre-commit.sample	      pre-rebase.sample
fsmonitor-watchman.sample  pre-merge-commit.sample    pre-receive.sample
post-update.sample	   prepare-commit-msg.sample  update.sample The hooks directory comes with some sample scripts. The extension stops them from running by default. All you need to do to "install" a hook is to get rid of the extension. .sample .sample Or, if you're starting from scratch with a new script, you may just add a new file with a name that matches one of the filenames listed above, but without the extension. .sample For our use case, we will need to have a commit-msg hook. Go ahead and create a new script named . commit-msg ~/projects/git_hooks_tut/.git/hooks$ touch commit-msg Let us add the logic to ensure our commit message pattern to script. commit-msg #!/bin/sh

commit_msg_file=$1
commit_msg=$(cat "$commit_msg_file")

# Check if the commit message starts with "TASK"
if ! echo "$commit_msg" | grep -q "^TASK"; then
  echo "Commit message must start with 'TASK'"
  exit 1
fi Lastly, make the script executable. Non-executable scripts are skipped by git even if they are present in the hooks directory. commit-msg ~/projects/git_hooks_tut/.git/hooks$ chmod +x commit-msg And with that setup, our hooks are complete! Let us test it now. We will now create a new file and try to commit it; first, with an invalid message format, and then with a valid message format. ~/projects/git_hooks_tut/.git/hooks$ cd ../..
~/projects/git_hooks_tut$ touch README
~/projects/git_hooks_tut$ ls
README
~/projects/git_hooks_tut$ git add README
~/projects/git_hooks_tut$ git commit -m "Added Readme File"
Commit message must start with 'TASK'
~/projects/git_hooks_tut$ git commit -m "TASK-0000: Added Readme File"
[master (root-commit) 7f3648a] TASK-000: Added Readme File Things are working ideally! What Are Some Different Kinds of Hooks Available? Git allows us to create hooks for a number of execution points. Some of these are as follows - This hook is executed before a commit is created. It allows us to validate the changes that are being committed. Pre-Commit Hook: The pre-receive hook is run on the remote repository prior to any references being modified, allowing you to apply custom rules or policies. Pre-Receive Hook: This hook is also executed on the remote repository after the updation of the references. It can be used to send notifications and/or perform additional tasks. Post-Receive Hook: This hook is executed before a push is made. This can be used to enforce certain policies that discourage pushing certain types of commits. Pre-Push Hook: The prepare-commit-msg hook is executed after a commit message is created, allowing you to modify or enhance the commit message. Prepare-Commit-Msg Hook: There are various other hooks present to better customize Git, they can be found on . Git docs Git hooks, if used properly, are a tool of great potential! We, the developers, often undermine the strength of such tools that could solve many complex tasks. Employing Git Hooks enhances DevOps at any level could be a great way for organizations looking to integrate DevOps in their development cycles. Congratulations on reaching this far! I hope you learned something new today.

Supercharge Your DevOps With Git Hooks

Potencia tus DevOps con Git Hooks

Boostez votre DevOps avec Git Hooks

Git Hooks के साथ अपने DevOps को सुपरचार्ज करें

Git フックで DevOps を強化する

Turbine seu DevOps com Git Hooks

Tăng cường DevOps của bạn bằng Git Hook

使用 Git Hooks 增强您的 DevOps

Today, developers have a variety of architectural choices to consider when designing and deploying their applications. Among these choices are serverless application model (SAM), , and on-premises architectures, each with its own distinct features, benefits, and considerations. In this article, we'll dive into these three architectural approaches, compare their main differences, and outline the pros and cons of each. cloud Serverless Architecture: Embracing Scalability and Efficiency is a paradigm that allows developers to focus solely on writing code without worrying about server provisioning, scaling, or maintenance. In a serverless model, cloud providers (AWS, Azure, GCP, etc.) manage the infrastructure and automatically scale resources based on demand. This results in highly efficient resource utilization and cost savings. Serverless architecture Pros: Serverless platforms automatically scale the number of instances up or down based on demand. This ensures optimal performance during traffic spikes without manual intervention. Scalability: With serverless, you only pay for the actual usage of resources, eliminating the need to pay for idle server time. This cost-effective model is suitable for applications with variable or sporadic workloads. Cost Efficiency: Serverless encourages a microservices architecture, where each function handles a specific task. This modular approach makes applications easier to develop, test, and maintain. Microservices Architecture: Serverless abstracts away the need for managing servers, databases, and other infrastructure components. This simplifies deployment and reduces the complexity of DevOps processes. Reduced Infrastructure Management: Serverless platforms are often offered by major cloud providers with data centers around the world. This enables applications to be easily deployed in multiple geographic regions for improved performance and availability. Global Reach: Serverless platforms support various programming languages, allowing developers to choose the language they are most comfortable with. Flexibility: Cons: Serverless functions experience "cold starts" when they are invoked after being idle for some time. During a cold start, the function container needs to be initialized, which can introduce latency. This can impact real-time applications that require low-latency responses. Cold Start Latency: While SAM abstracts away infrastructure management, it can lead to vendor lock-in with the cloud provider offering the serverless platform. Migrating to another platform may require significant changes to application code and configurations. Vendor Lock-In: Serverless functions run in constrained execution environments with limited resources (CPU, memory, etc.). This can pose challenges for applications that require resource-intensive processing. Limited Execution Environment: Serverless functions are designed to be stateless, which can complicate applications that require complex state management across function invocations. Developers need to implement external storage solutions for state persistence. State Management: Debugging and testing serverless functions can be challenging due to their ephemeral nature. Developers must rely on logging and monitoring tools to identify issues during runtime. Debugging and Testing: Cloud Architecture: Flexible and Scalable Infrastructure Cloud architecture involves deploying applications and services on remote servers provided by third-party cloud service providers. This approach offers a balance between control and convenience, allowing businesses to access a wide range of services and resources. Pros: , allowing you to quickly scale up or down based on demand. This ensures optimal performance during traffic spikes and minimizes infrastructure costs during periods of lower demand. Scalability: Cloud platforms provide elastic scalability Cloud services operate on a pay-as-you-go model, allowing businesses to avoid upfront capital expenses for hardware and infrastructure. This cost-effective approach aligns costs with actual usage, making it suitable for businesses of all sizes. Cost Efficiency: Cloud providers have data centers distributed globally. This enables businesses to easily deploy applications in multiple geographic regions, improving performance and availability for a global user base. Global Reach: Cloud platforms offer a wide range of services, including computing, storage, databases, machine learning, and more. This flexibility allows businesses to choose the right tools for their specific needs and quickly experiment with new technologies. Flexibility and Agility: Cloud services provide tools and automation for rapid application deployment. This speeds up the development cycle and shortens the time-to-market for new features and products. Rapid Deployment: Cons: While cloud services can initially appear cost-effective due to their pay-as-you-go model, costs can escalate rapidly as usage increases. Organizations might face unexpected expenses if they do not carefully monitor and manage their resources. Cost Variability: Cloud services' performance can sometimes be influenced by the "noisy neighbor" effect, where other users on the same physical hardware affect your application's performance. This can lead to unpredictable performance issues. Performance Variability: While cloud providers handle much of the infrastructure management, organizations have less control over the underlying hardware, network configurations, and software stack. Limited Control: Depending on the geographic location of the cloud data centers, latency might be a concern for applications requiring real-time interactions. Additionally, transferring data in and out of the cloud can result in additional costs. Latency and Data Transfer Costs: Cloud services, while generally reliable, are not immune to outages. Organizations need to have contingency plans in place to mitigate the impact of downtime on their operations. Downtime and Outages: On-Premises Architecture: Full Control and Data Privacy On-premises architecture involves hosting applications and services within an organization's own data centers or physical infrastructure. This approach offers complete control over resources and data, making it suitable for businesses with strict data security and compliance requirements. Pros: On-premises architecture provides you with complete control over your data and infrastructure. This can be especially important for industries with strict compliance regulations or sensitive data. Data Control and Security: With on-premises solutions, you have the freedom to customize your hardware, software, and network configurations to suit your specific needs. This can lead to optimized performance and tailored solutions. Customization: Unlike cloud services, which often have usage-based pricing, on-premises architecture generally involves upfront costs for hardware and infrastructure. This can lead to more predictable and stable budgeting over time. Predictable Costs: On-premises architecture keeps your data within your physical control, reducing the risk of data breaches or unauthorized access that might occur with cloud-based solutions. Data Privacy: On-premises architecture allows you to choose your own hardware and software vendors, eliminating concerns about vendor lock-in and allowing you to switch providers if needed. No Vendor Lock-In: Cons: On-premises architecture typically involves significant upfront costs for purchasing hardware, software licenses, and infrastructure setup. This can be a barrier for smaller businesses or startups with limited budgets. Higher Upfront Costs: With on-premises solutions, your organization is responsible for ongoing maintenance, updates, and troubleshooting. This requires dedicated IT staff and resources to ensure smooth operations. Maintenance and Support: Scaling up on-premises infrastructure can be complex and time-consuming. Adding new servers or resources often requires purchasing and setting up new hardware, which can lead to delays in responding to increased demand. Scalability Challenges: On-premises solutions are less flexible in terms of scaling resources up or down quickly based on demand fluctuations. This can lead to overprovisioning or underutilization of resources. Limited Flexibility: Maintaining redundancy and failover mechanisms on-premises can be more challenging and expensive compared to cloud-based solutions, potentially leading to higher downtime risks. Lack of Redundancy: If your organization operates across multiple locations or requires remote access, on-premises architecture may not provide the same level of accessibility as cloud solutions. Geographic Constraints: While on-premises solutions offer greater control over data security, they also place the responsibility squarely on your organization. Implementing robust security measures requires expertise and ongoing vigilance. Security Concerns: On-premises architectures may lack the agility to quickly adopt new technologies, services, or features that cloud providers frequently offer. Lack of Agility: In conclusion, choosing the right architecture depends on your business goals, technical requirements, and resource constraints. Serverless architecture offers ease of use and scalability, provides flexibility and a wide array of services, while on-premises architecture offers data control and customization. By carefully evaluating your needs and considering the pros and cons of each approach, you can make an informed decision that aligns with your organization's objectives. cloud architecture

Exploring Serverless, Cloud, and On-Premises Architectures

The React way of dynamically updating a website’s content is different from Vanilla JavaScript. In JavaScript, we do it by directly manipulating DOM, whereas in React, we have a feature called . useState It is one of the built-in hooks in React. It helps us to declare state variables in Functional Components. We pass the initial state to the useState hook, and in return, it gives us a variable with our state value and a function to update the value. Now let’s compare both ways (JavaScript and React) with an example. Suppose you’ve been given a bag filled with five apples and after some time, you are given seven more apples to put into your bag. Now how many apples will you have in your bag? It's 5+7=12, right? Let’s see how we can show this example in both JavaScript and React: The JavaScript Way I’ve created this HTML/CSS/JS code template to show this example live; you can access it . repl.it here HTML <!DOCTYPE html>
<html>
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
   <title>replit</title>
   <link href="style.css" rel="stylesheet" type="text/css" />
 </head>
 <body>
   <div>
     <p>Apples</p>
     <p class="value">5</p>
     <button>Update values</button>
   </div>
   <script src="script.js"></script>
 </body>
</html> JavaScript const value = document.querySelector('.value')
const button = document.querySelector('button')

let realValue = parseInt(value.innerHTML)
let updateValue = () => {
 realValue+=7
 return value.innerHTML = realValue
}
button.addEventListener('click', updateValue) Code Explanation We’ve created two HTML paragraphs - , added a class called value to 5 to update it later, and created a button called . apples and 5 Update values In our JavaScript code, We stored the class and the button into two different variables. value Next, we used function to convert the value of our apples into integers and store it into another variable called . parseInt() realValue Then we created a function called , inside which we first added 7 to the current value of the variable and assigned this updated to the HTML value of our variable with the help of . updateValue realValue realValue value .innerHTML Finally, we added the click event listener to our button to call the function every time the button gets clicked. updateValue The React Way - useState() Check out the repl of the same app created with React, . here App.js import React, {useState} from 'react';
import './App.css';

function App() {

 const [apples, setApples] = useState(5)
 const updateApples = () => {
   return setApples(apples+7)
 }
 return (
   <div>
     <p>Apples</p>
     <p>{apples}</p>
     <button onClick={updateApples}>Update Apples</button>
   </div>
 );
}

export default App; Code Explanation We start with importing React and useState from React. const [apples, setApples] = useState(5) The snippet above is the standard way of declaring useState. Here useState gives us a variable called with the value of 5 as initialized under the function call and another function called to update the value of variable. apples useState setApples apples Next, we declared a function called which will be called every time someone clicks our button, which is yet to be declared. updateApples Update Apples return setApples(apples+7) In the above snippet, we return function call and add 7 to the variable as an argument. This is how the state is updated in useState. setApples() apples return (
   <div>
     <p>Apples</p>
     <p>{apples}</p>
     <button onClick={updateApples}>Update Apples</button>
   </div>
 );
} Now finally, we made our return statement. We returned an element with 2 paragraph elements, one for and one for the value of apples, similar to how we did this in the JavaScript version. The twist here is that instead of directly writing the value, we used the variable from the hook to declare the value of apples. <div> Apples apples useState() And at last, we created a button and attached the the function we declared earlier to the event handler. updateApples onClick Up to this point in the article, we have learned hook, and how it works and compared it with DOM manipulation in Vanilla JavaScript. Now before ending this article, we’ll build a Counter App, which is the classic example of and React. useState() useState() Counter App with useState() Before starting, if you want to know how this app will work, you can check out this . repl Code import React, {useState} from 'react';
import './App.css';

function App() {

 const [addCount, setAddCount] = useState(0);
 const [subtractCount, setSubtractCount] = useState(0);

 return (
   <div>
     <p>Your value is {addCount}</p>
     <button onClick={() => setAddCount(addCount + 1)}>
       Add
     </button>

     <p>Your value is {subtractCount}</p>
     <button onClick={() => setSubtractCount(subtractCount - 1)}>
       Subtract
     </button>
   </div>
 );
}
export default App; Explanation In our function, we declared 2 hooks, one for up the values in the counter and the other one for the values as you can see in their names. Both useStates are initialized with the value of 0. App() useState() adding subtracting The return statement returns an element with two elements and two elements for our and variables. <div> <p> <button> addCount subtractCount Both paragraphs show as a default text followed by their respective state variables, i.e., and . These state variables display their current value on the screen. Your value is addCount subtractCount Then there are two buttons that call their respective and functions to add or subtract values from our state variables. setAddCount() setSubtractCount() Great, now both the Update Apple and Counter App are finished, and I hope you would have understood by now what useState hook is and how it works. If yes, show your love by sharing your thoughts and the article on social media. Happy Coding ✌️ Also published . here

React useState() Made Easy for Beginners

The primary goal of a DTO is to simplify communication between different layers of an application, particularly when transmitting data through various boundary interfaces such as web services, REST APIs, message brokers, or other mechanisms of remote interaction. When exchanging information with other systems, it is crucial to minimize unnecessary costs, such as redundant serialization/deserialization, and to ensure a clear data structure that represents a specific contract between the sender and receiver. In this article, I intend to explore the capabilities that Python offers for implementing DTOs. Starting from built-in tools and extending to specialized libraries. Among the core functionalities, I want to emphasize type and data validation, object creation, and conversion to dictionaries. DTO Based on a Python Class Let's consider an example of a DTO based on a Python class. Let's assume we have a user model that includes a first name and a last name: class UserDTO:
   def __init__(self, **kwargs):
       self.first_name = kwargs.get("first_name")
       self.last_name = kwargs.get("last_name")
       self.validate_lastname()


   def validate_lastname(self):
       if len(self.last_name) <= 2:
           raise ValueError("last_name length must be more then 2")


   def to_dict(self):
       return self.__dict__


   @classmethod
   def from_dict(cls, dict_obj):
       return cls(**dict_obj) We have implemented methods in the DTO class for creating an instance of the class, converting data to a dictionary, and adding validation logic. Now, let's see how this can be used: >>> user_dto = UserDTO.from_dict({'first_name': 'John', 'last_name': 'Doe'})
>>> user_dto.to_dict()
{'first_name': 'John', 'last_name': 'Doe'}

>>> user_dto = UserDTO.from_dict({'first_name': 'John', 'last_name': 'Do'})
ValueError: last_name length must be more then 2 This is a highly simplified example. This approach allows you to implement various functionalities. The only downside is that you need to define everything manually, and even with inheritance, there might be a significant amount of code. NamedTuple Another way to create a DTO in Python is by using . NamedTuple is a class from the Python standard library (introduced in Python 3.6) representing an immutable tuple with named properties. It is a typed and more readable version of the class from the module. NamedTuple namedtuple collections We can create a DTO based on , containing the first name and last name of a user from the example using classes: NamedTuple from typing import NamedTuple

class UserDTO(NamedTuple):
    first_name: str
    last_name: str Now, we can create UserDTO objects as follows, as well as convert the object to a dictionary and create an object from a dictionary: >>> user_dto = UserDTO(**{'first_name': 'John', 'last_name': 'Doe'})
>>> user_dto.first_name
'John'
>>> user_dto
UserDTO(first_name='John', last_name='Doe'})
>>> user_dto._asdict()
{'first_name': 'John', 'last_name': 'Doe'}
>>> user_dto.first_name = 'Bill'
AttributeError: can't set attribute There is no built-in type and data validation, but it provides a more compact definition and a readable format. It is also immutable, which provides more security during operation. Only the defined arguments can be passed as input, and there is a method for converting it to a dictionary. _asdict For more details, see . here TypedDict Another option for creating DTO objects in Python is to use , which has been introduced in the language starting from version 3.8. This data type allows you to create dictionaries with a fixed set of keys and annotations for value types. TypedDict This approach makes a good choice for creating DTO objects when you need to use a dictionary with a specific set of keys. TypedDict To create an object, you need to import the data type from the typing module. Let's create a for the user model: TypedDict TypedDict from typing import TypedDict

class UserDTO(TypedDict):
   first_name: str
   last_name: str In this example, we define the class, which is a subclass of . We can create a object and populate it with data: UserDTO TypedDict UserDTO >>> user_dto = UserDTO(**{first_name: 'John', last_name: 'Doe'})
>>> user_dto
{first_name: 'John', last_name: 'Doe'}
>>> type(user_dto)
<class 'dict'> We can use it to define dictionaries with a fixed set of keys and annotations for value types. This makes the code more readable and predictable. Additionally, provides the ability to use dictionary methods such as keys() and values(), which can be useful in certain cases. TypedDict For more details, see . here Dataclass is a decorator that provides a simple way to create classes for storing data. uses type annotations to define fields and then generates all the necessary methods for creating and using objects of that class. Dataclass Dataclass To create a DTO using , you need to add the decorator and define fields with type annotations. For example, we can create a DTO for a user model using like this: dataclass dataclass dataclass from dataclasses import asdict, dataclass

@dataclass
class UserDTO:
   first_name: str
   last_name: str = ''


   def __post_init__(self):
       self.validate_lastname()


   def validate_lastname(self):
       if len(self.last_name) <= 2:
           raise ValueError("last_name length must be more then 2") Now, we can easily create objects, convert them to dictionaries, and create new objects based on dictionaries: UserDTO >>> user_dto = UserDTO(**{'first_name': 'John', 'last_name': 'Doe'})
>>> user_dto
UserDTO(first_name='John', last_name='Doe')
>>> asdict(user_dto)
{'first_name': 'John', 'last_name': 'Doe'}
>>> user_dto = UserDTO(**{'first_name': 'John', 'last_name': 'Do'})
ValueError: last_name length must be more then 2 To create an immutable object, you can pass the argument to the decorator. There's an method for converting to a dictionary. Additionally, you can implement validation methods and use default values. frozen=True asdict In general, are more compact than plain classes and more functional than the previously discussed options. dataclasses For more details, see . here Attr Another way to create DTOs is by using the module. It works similarly to but is more functional and provides a more compact description. This library can be installed using the command . attr dataclass pip install attrs import attr


@attr.s
class UserDTO:
   first_name: str = attr.ib(default="John", validator=attr.validators.instance_of(str))
   last_name: str = attr.ib(default="Doe", validator=attr.validators.instance_of(str)) Here, using the decorator, we define a DTO class with attributes and , while also setting default values and validation. first_name last_name >>> user_dto = UserDTO(**{'first_name': 'John', 'last_name': 'Doe'})
>>> user_dto
UserDTO(first_name='John', last_name='Doe')
>>> user_dto = UserDTO()
>>> user_dto
UserDTO(first_name='John', last_name='Doe')
>>> user_dto = UserDTO(**{'first_name': 1, 'last_name': 'Doe'})
TypeError: ("'first_name' must be <class 'str'>... In this way, the module offers powerful and flexible tools for defining DTO classes, such as validation, default values, and transformations. The DTO object can also be made immutable using the decorator attribute . It can also be initialized through the decorator. attrs frozen=True define For more details, see . here Pydantic library is a tool for data validation and data conversion in Python. It utilizes type annotations to define data schemas and converts JSON data into Python objects. Pуdantic is used for the convenient handling of data from web requests, configuration files, databases, and other scenarios where data validation and conversion are required. Pydantic It can be installed using the command pip install pydantic. from pydantic import BaseModel, Field, field_validator


class UserDTO(BaseModel):
   first_name: str
   last_name: str = Field(min_length=2, alias="lastName")
   age: int = Field(lt=100, description="Age must be a positive integer")
   
   @field_validator("age")
   def validate_age(cls, value):
       if value < 18:
           raise ValueError("Age must be at least 18")
       return value In this example, we've defined a model with basic validations for string length and maximum age. We've also specified that data for the attribute will come through the parameter . UserDTO last_name lastName Additionally, as an example, a custom validator for minimum age is demonstrated. >>> user_dto = UserDTO(**{'first_name': 'John', 'lastName': 'Doe', 'age': 31})
>>> user_dto
UserDTO(first_name='John', last_name='Doe', age=31)

>>> user_dto.model_dump()
{'first_name': 'John', 'last_name': 'Doe', 'age': 31}

>>> user_dto.model_dump_json()
'{"first_name":"John","last_name":"Doe","age":31}'


>>> user_dto = UserDTO(**{'first_name': 'John', 'lastName': 'D', 'age': 3})
pydantic_core._pydantic_core.ValidationError: 2 validation errors for UserDTO
lastName
    String should have at least 2 characters [type=string_too_short, input_value='D', input_type=str]
age
    Value error, Age must be at least 18 [type=value_error, input_value=3, input_type=int] is a versatile tool. It is the default data schema and validation tool used in FastAPI. It simplifies the serialization and deserialization of objects to JSON format using built-in methods and provides more readable runtime hints. Pydantic For more details, see . here Conclusion In this article, I covered different ways of implementing DTOs in Python, starting from simple approaches to more complex ones. The choice of which method to use for your project depends on various factors. This includes the Python version in your project and whether you have the ability to install new dependencies. It also depends on whether you plan to use validation, conversion, or if simple type annotations are sufficient. I hope this article will help those who are seeking suitable methods for implementing DTOs in Python for their projects.

Initialized

initialized.com

-- employees

Since n.d.

COMPANY RANKING

Initialized

EVERGREEN INDEX #1390

See more notable links about Initialized

Apply to get your Tech Company News Page live on HackerNoon.com today!

Read More Tech Stories Related to #Initialized

Initialized

Initialized

initialized.com

-- employees

Since n.d.

COMPANY RANKING

Initialized

EVERGREEN INDEX #1390

Related CompaniesRank

Initialized Story MentionsComplete List

See more notable links about Initialized

Apply to get your Tech Company News Page live on HackerNoon.com today!

Read More Tech Stories Related to #Initialized

Initialized