pieFi

piefi

Avoid Using the Prefix "Collection" on Properties TL;DR: Drop "collection" prefix for clarity. Problems Redundant Naming
Verbose Code
Reduced Readability
Refactoring Challenges
Coupled to implementation Solutions Use Simple Names
Remove 'collection' from the name
Use plural names without the word 'collection.' Context When you prefix properties with terms like "collection," you introduce redundancy and verbosity into your code. This makes your code harder to read and maintain and adds unnecessary complexity. Coupling the name to a collection implementation prevents you from introducing a proxy or middle object to manage the relation. Sample Code Wrong struct Task {
    collection_of_subtasks: Vec<Subtask>,
    subtasks_collection: Vec<Subtask>,
}

impl Task {
    fn add_subtask(&mut self, subtask: Subtask) {
        self.collection_of_subtasks.push(subtask);
        self.subtasks_collection.push(subtask);
    }
} Right struct Task {
    subtasks: Vec<Subtask>,
}

impl Task {
    fn add_subtask(&mut self, subtask: Subtask) {
        self.subtasks.push(subtask);
    }
} Detection [x]Automatic You can add rules to your linter preventing these redundant names. Tags Naming Level [x]Beginner AI Generation AI code generators produce this smell if they try to over-describe property names. They tend to generate overly verbose names to be explicit, which can lead to redundancy. AI Detection AI tools can fix this smell if you instruct them to simplify property names. They can refactor your code to use more concise and clear names. Conclusion Simplifying property names by removing prefixes like "collection" leads to more readable and maintainable code. It would be best to focus on clear, direct names that communicate the purpose without redundancy. Relations Code Smell 38 - Abstract Names Code Smell 171 - Plural Classes Code Smell 113 - Data Naming More Info What exactly is a name - Part II Rehab Disclaimer Code Smells are my opinion. Credits Photo by Karen Vardazaryan on Unsplash Good design adds value faster than it adds cost. Thomas C. Gale Software Engineering Great Quotes This article is part of the CodeSmell Series. How to Find the Stinky Parts of your Code Avoid Using the Prefix "Collection" on Properties Avoid Using the Prefix "Collection" on Properties TL;DR: Drop "collection" prefix for clarity. TL;DR: Drop "collection" prefix for clarity. Problems Redundant Naming Verbose Code Reduced Readability Refactoring Challenges Coupled to implementation Redundant Naming Verbose Code Reduced Readability Refactoring Challenges Coupled to implementation Solutions Use Simple Names Remove 'collection' from the name Use plural names without the word 'collection.' Use Simple Names Remove 'collection' from the name from the name Use plural names without the word 'collection.' Context When you prefix properties with terms like "collection," you introduce redundancy and verbosity into your code. This makes your code harder to read and maintain and adds unnecessary complexity. Coupling the name to a collection implementation prevents you from introducing a proxy or middle object to manage the relation. Sample Code Wrong struct Task {
    collection_of_subtasks: Vec<Subtask>,
    subtasks_collection: Vec<Subtask>,
}

impl Task {
    fn add_subtask(&mut self, subtask: Subtask) {
        self.collection_of_subtasks.push(subtask);
        self.subtasks_collection.push(subtask);
    }
} struct Task {
    collection_of_subtasks: Vec<Subtask>,
    subtasks_collection: Vec<Subtask>,
}

impl Task {
    fn add_subtask(&mut self, subtask: Subtask) {
        self.collection_of_subtasks.push(subtask);
        self.subtasks_collection.push(subtask);
    }
} Right struct Task {
    subtasks: Vec<Subtask>,
}

impl Task {
    fn add_subtask(&mut self, subtask: Subtask) {
        self.subtasks.push(subtask);
    }
} struct Task {
    subtasks: Vec<Subtask>,
}

impl Task {
    fn add_subtask(&mut self, subtask: Subtask) {
        self.subtasks.push(subtask);
    }
} Detection [x]Automatic [x] Automatic [x] You can add rules to your linter preventing these redundant names. Tags Naming Naming Level [x]Beginner [x] Beginner [x] AI Generation AI code generators produce this smell if they try to over-describe property names. They tend to generate overly verbose names to be explicit, which can lead to redundancy. AI Detection AI tools can fix this smell if you instruct them to simplify property names. They can refactor your code to use more concise and clear names. Conclusion Simplifying property names by removing prefixes like "collection" leads to more readable and maintainable code. It would be best to focus on clear, direct names that communicate the purpose without redundancy. Relations Code Smell 38 - Abstract Names Code Smell 38 - Abstract Names Code Smell 171 - Plural Classes Code Smell 171 - Plural Classes Code Smell 113 - Data Naming Code Smell 113 - Data Naming More Info What exactly is a name - Part II Rehab What exactly is a name - Part II Rehab Disclaimer Code Smells are my opinion . opinion Credits Photo by Karen Vardazaryan on Unsplash Karen Vardazaryan Unsplash Good design adds value faster than it adds cost. Good design adds value faster than it adds cost. Thomas C. Gale Thomas C. Gale Software Engineering Great Quotes Software Engineering Great Quotes This article is part of the CodeSmell Series. How to Find the Stinky Parts of your Code How to Find the Stinky Parts of your Code

Code Smell 257 - Simplifying Property Names By Removing Prefixes

Authors:
(1) PIOTR MIROWSKI and KORY W. MATHEWSON, DeepMind, United Kingdom and Both authors contributed equally to this research;
(2) JAYLEN PITTMAN, Stanford University, USA and Work done while at DeepMind;
(3) RICHARD EVANS, DeepMind, United Kingdom. Table of Links Abstract and Intro Storytelling, The Shape of Stories, and Log Lines The Use of Large Language Models for Creative Text Generation Evaluating Text Generated by Large Language Models Participant Interviews Participant Surveys Discussion and Future Work Conclusions, Acknowledgements, and References A. RELATED WORK ON AUTOMATED STORY GENERATION AND CONTROLLABLE STORY GENERATION B. ADDITIONAL DISCUSSION FROM PLAYS BY BOTS CREATIVE TEAM C. DETAILS OF QUANTITATIVE OBSERVATIONS D. SUPPLEMENTARY FIGURES E. FULL PROMPT PREFIXES FOR DRAMATRON F. RAW OUTPUT GENERATED BY DRAMATRON G. CO-WRITTEN SCRIPTS E FULL PROMPT PREFIXES FOR DRAMATRON E.1 About the Prompt Sets In our study we relied on two sets of prompts: Medea and Sci-Fi. Medea prompts are based on Ancient Greek tragedy Medea, by Euripides (431 BC). The dialogue prompts were taken verbatim from the translation of the play by E. P. Coleridge (1863 - 1936), available in the public domain[13]. We replaced CHORUS by WOMEN OF CORINTH. The plot and character prompts were written from a summary taken from Spark Notes[14] and Wikipedia[15]. To encourage the generation of different locations, Aristotle’s Unity of Place is not respected, and location “Outside the Royal Palace” is renamed as “Medea’s modest home” as well as “On a winged chariot” (even though these are the same locations in the original tragedy). Prompts for Antigone[16] (Sophocles), The Bacchae[17] (Euripides), and The Frogs[18] (Aristophanes) were adapted from Wikipedia and ancient-literature.com The Star Wars log line was adapted from chapter “Creating the killer log line” by Bill Lundy[19]. Sci-Fi character prompts were adapted from Star Wars: Episode IV - A New Hope (1977), written and directed by George Lucas, produced by Lucasfilm and distributed by 20th Century Fox. We also adapted the breakdown of Star Wars into a Hero Journey[20]. The script[21], plot[22] and log line[23] of Plan 9 from Outer Space, which is in public domain. E.2 Title Prompt Prefixes In the following sets of prompt prefixes, the <LOG_LINE> is provided by the writer. E.3 Character Description Prompt Prefixes In the following sets of prompt prefixes, the <LOG_LINE> is provided by the writer. E.4 Plot Outline Prompt Prefixes In the following sets of prompt prefixes, the <LOG_LINE>is provided by the writer and each <CHARACTER_DESCRIPTION> is generated in the previous step. E.5 Location Description Prompt Prefixes In the following sets of prompt prefixes, the <LOG_LINE> is provided by the writer and each <LOCATION_NAME> is generated in the previous step. E.6 Scene Dialogue Prompt Prefixes In the following sets of prompt prefixes, the <LOG_LINE> is provided by the writer, <PLOT_ELEMENT>, <BEAT>, <PREVIOUS_BEAT> and <LOCATION_NAME> are generated during the plot outline generation step, <LOCATION_DESCRIPTION> is generated during the location generation step, <CHARACTER_DESCRIPTION>and each is generated in the character generation step. <PREVIOUS_BEAT> corresponds to <BEAT>from the previous scene (it is left empty for the first scene). Only characters whose name appears in the beat are used in this prompt prefix (we use string matching to select these character names). This paper is available on arxiv under CC 4.0 license. [13] http://classics.mit.edu/Euripides/medea.pl.txt [14] https://www.sparknotes.com/lit/medea/ [15] https://en.wikipedia.org/wiki/Medea_(play) [16] https://www.ancient-literature.com/greece_sophocles_antigone.html [17] https://en.wikipedia.org/wiki/The_Bacchae [18] https://www.ancient-literature.com/greece_aristophanes_frogs.html [19] In Ellis, Sherry, and Laurie Lamson. “Now Write! Mysteries: Suspense, Crime, Thriller, and Other Mystery Fiction Exercises from Today’s Best Writers and Teachers.”, Penguin, 2011 [20] https://thescriptlab.com/features/screenwriting-101/12309-the-heros-journey-breakdown-star-wars/ [21] http://www.horrorlair.com/scripts/criswell.txt [22] https://en.wikipedia.org/wiki/Plan_9_from_Outer_Space [23] https://www.rottentomatoes.com/m/plan-9-from-outer-space Authors: (1) PIOTR MIROWSKI and KORY W. MATHEWSON, DeepMind, United Kingdom and Both authors contributed equally to this research; (2) JAYLEN PITTMAN, Stanford University, USA and Work done while at DeepMind; (3) RICHARD EVANS, DeepMind, United Kingdom. Authors: Authors: (1) PIOTR MIROWSKI and KORY W. MATHEWSON, DeepMind, United Kingdom and Both authors contributed equally to this research; (2) JAYLEN PITTMAN, Stanford University, USA and Work done while at DeepMind; (3) RICHARD EVANS, DeepMind, United Kingdom. Table of Links Abstract and Intro Abstract and Intro Storytelling, The Shape of Stories, and Log Lines Storytelling, The Shape of Stories, and Log Lines The Use of Large Language Models for Creative Text Generation The Use of Large Language Models for Creative Text Generation Evaluating Text Generated by Large Language Models Evaluating Text Generated by Large Language Models Participant Interviews Participant Interviews Participant Surveys Participant Surveys Discussion and Future Work Discussion and Future Work Conclusions, Acknowledgements, and References Conclusions, Acknowledgements, and References A. RELATED WORK ON AUTOMATED STORY GENERATION AND CONTROLLABLE STORY GENERATION A. RELATED WORK ON AUTOMATED STORY GENERATION AND CONTROLLABLE STORY GENERATION B. ADDITIONAL DISCUSSION FROM PLAYS BY BOTS CREATIVE TEAM B. ADDITIONAL DISCUSSION FROM PLAYS BY BOTS CREATIVE TEAM C. DETAILS OF QUANTITATIVE OBSERVATIONS C. DETAILS OF QUANTITATIVE OBSERVATIONS D. SUPPLEMENTARY FIGURES D. SUPPLEMENTARY FIGURES E. FULL PROMPT PREFIXES FOR DRAMATRON E. FULL PROMPT PREFIXES FOR DRAMATRON F. RAW OUTPUT GENERATED BY DRAMATRON F. RAW OUTPUT GENERATED BY DRAMATRON G. CO-WRITTEN SCRIPTS G. CO-WRITTEN SCRIPTS E FULL PROMPT PREFIXES FOR DRAMATRON E.1 About the Prompt Sets In our study we relied on two sets of prompts: Medea and Sci-Fi. Medea prompts are based on Ancient Greek tragedy Medea, by Euripides (431 BC). The dialogue prompts were taken verbatim from the translation of the play by E. P. Coleridge (1863 - 1936), available in the public domain[13]. We replaced CHORUS by WOMEN OF CORINTH. The plot and character prompts were written from a summary taken from Spark Notes[14] and Wikipedia[15]. To encourage the generation of different locations, Aristotle’s Unity of Place is not respected, and location “Outside the Royal Palace” is renamed as “Medea’s modest home” as well as “On a winged chariot” (even though these are the same locations in the original tragedy). Prompts for Antigone[16] (Sophocles), The Bacchae[17] (Euripides), and The Frogs[18] (Aristophanes) were adapted from Wikipedia and ancient-literature.com The Star Wars log line was adapted from chapter “Creating the killer log line” by Bill Lundy[19]. Sci-Fi character prompts were adapted from Star Wars: Episode IV - A New Hope (1977), written and directed by George Lucas, produced by Lucasfilm and distributed by 20th Century Fox. We also adapted the breakdown of Star Wars into a Hero Journey[20]. The script[21], plot[22] and log line[23] of Plan 9 from Outer Space, which is in public domain. E.2 Title Prompt Prefixes In the following sets of prompt prefixes, the < LOG_LINE > is provided by the writer. LOG_LINE E.3 Character Description Prompt Prefixes In the following sets of prompt prefixes, the < LOG_LINE > is provided by the writer. LOG_LINE E.4 Plot Outline Prompt Prefixes In the following sets of prompt prefixes, the < LOG_LINE >is provided by the writer and each < CHARACTER_DESCRIPTION > is generated in the previous step. LOG_LINE CHARACTER_DESCRIPTION E.5 Location Description Prompt Prefixes In the following sets of prompt prefixes, the <LOG_LINE> is provided by the writer and each < LOCATION_NAME > is generated in the previous step. LOCATION_NAME E.6 Scene Dialogue Prompt Prefixes In the following sets of prompt prefixes, the < LOG_LINE > is provided by the writer, < PLOT_ELEMENT >, < BEAT >, < PREVIOUS_BEAT > and < LOCATION_NAME > are generated during the plot outline generation step, < LOCATION_DESCRIPTION > is generated during the location generation step, < CHARACTER_DESCRIPTION >and each is generated in the character generation step. < PREVIOUS_BEAT > corresponds to < BEAT >from the previous scene (it is left empty for the first scene). Only characters whose name appears in the beat are used in this prompt prefix (we use string matching to select these character names). LOG_LINE PLOT_ELEMENT BEAT PREVIOUS_BEAT LOCATION_NAME LOCATION_DESCRIPTION CHARACTER_DESCRIPTION PREVIOUS_BEAT BEAT This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv [13] http://classics.mit.edu/Euripides/medea.pl.txt [14] https://www.sparknotes.com/lit/medea/ [15] https://en.wikipedia.org/wiki/Medea_(play) [16] https://www.ancient-literature.com/greece_sophocles_antigone.html [17] https://en.wikipedia.org/wiki/The_Bacchae [18] https://www.ancient-literature.com/greece_aristophanes_frogs.html [19] In Ellis, Sherry, and Laurie Lamson. “Now Write! Mysteries: Suspense, Crime, Thriller, and Other Mystery Fiction Exercises from Today’s Best Writers and Teachers.”, Penguin, 2011 [20] https://thescriptlab.com/features/screenwriting-101/12309-the-heros-journey-breakdown-star-wars/ [21] http://www.horrorlair.com/scripts/criswell.txt [22] https://en.wikipedia.org/wiki/Plan_9_from_Outer_Space [23] https://www.rottentomatoes.com/m/plan-9-from-outer-space

Diverse AI Prompt Prefixes for Scriptwriting: From Star Wars to Ancient Drama

When working with text in JavaScript, you may come across situations where you need to add a prefix or suffix to each new line in a given text. In this tutorial, we'll walk you through a simple and effective way to achieve this using HTML, CSS, and JavaScript. We'll create an easy-to-use online tool that adds a specified prefix and suffix to each new line of text entered by the user. Step 1: Create the HTML Structure First, let's create the basic for our tool. This includes a text area for inputting the text, two input fields for the prefix and suffix, a button to trigger the , and an output text area to display the processed text. HTML structure JavaScript function <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Add Prefix and Suffix</title>
</head>
<body>
    <h1>Add Prefix and Suffix to Each New Line</h1>
    <textarea id="inputText" rows="10" cols="50" placeholder="Enter your text here..."></textarea>
    <br>
    <label for="prefix">Prefix:</label>
    <input type="text" id="prefix" />
    <br>
    <label for="suffix">Suffix:</label>
    <input type="text" id="suffix" />
    <br>
    <button onclick="addPrefixAndSuffix()">Add Prefix and Suffix</button>
    <br>
    <h2>Output:</h2>
    <textarea id="outputText" rows="10" cols="50" readonly></textarea>
</body>
</html> Step 2: Add CSS for Styling Although not required, you may want to add some basic the tool. Here's a simple example: CSS to style <style>
    body {
        font-family: Arial, sans-serif;
        max-width: 800px;
        margin: 0 auto;
        padding: 20px;
    }

    textarea, input {
        display: block;
        width: 100%;
        margin-bottom: 10px;
    }

    button {
        background-color: #4CAF50;
        color: white;
        padding: 8px 16px;
        border: none;
        cursor: pointer;
        text-decoration: none;
    }

    button:hover {
        background-color: #45a049;
    }
</style> Add the above CSS code inside the tag of the HTML code to apply the styles. <head> Step 3: Write the JavaScript Function Now, let's write the JavaScript function that will add the specified prefix and suffix to each new line of the input text. Be sure to include this code within tags at the end of your HTML file, just before the closing tag. <script> </body> function addPrefixAndSuffix() {
    const inputText = document.getElementById('inputText').value;
    const prefix = document.getElementById('prefix').value;
    const suffix = document.getElementById('suffix').value;
    const lines = inputText.split('\n');

    const outputLines = lines.map(line => {
        if (line.trim() === '') {
            return line;
        }
        return prefix + line + suffix;
    });

    const outputText = outputLines.join('\n');
    document.getElementById('outputText').value = outputText;
} This function retrieves the input text, prefix, and suffix from the HTML elements. It then splits the input of lines, processes each line by adding the prefix and suffix (skipping empty or whitespace-only lines), and finally combines the processed lines back into a single string. text into an array Step 4: Test the Tool To test the , save the HTML, CSS, and JavaScript code in a new file and open it in your web browser. You should see a simple interface with input fields for the text, prefix, and suffix, as well as a button to trigger the function. tool .html Enter your text in the text area, input your desired prefix and suffix, and click the "Add Prefix and Suffix" button. The processed text with the added prefix and suffix should appear in the output text area. Conclusion In this tutorial, we have demonstrated how to create a user-friendly online tool that adds a prefix and suffix to each new line of text using HTML, CSS, and JavaScript. This tool can be helpful for tasks such as formatting lists, adding , or enhancing the appearance of your text. code snippets With this simple yet effective solution, you can save time and effort when working with text in JavaScript.

How to Add Prefix or Suffix to Each New Line in JavaScript

Task description: A (pronounced as “try”) or is a tree data structure used to efficiently store and retrieve keys in a dataset of strings. There are various applications of this data structure, such as autocomplete and spellchecker. trie prefix tree Implement the Trie class: Initializes the trie object. Trie() Inserts the string into the trie. void insert(String word) word Returns if the string is in the trie (i.e., was inserted before), and otherwise. boolean search(String word) true word false Returns if there is a previously inserted string that has the prefix , and otherwise. boolean startsWith(String prefix) true word prefix false Example 1: Input
["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
[[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
Output
[null, null, true, false, true, null, true] Explanation
Trie trie = new Trie();
trie.insert("apple");
trie.search("apple");   // return True
trie.search("app");     // return False
trie.startsWith("app"); // return True
trie.insert("app");
trie.search("app");     // return True Constraints: 1 <= word.length, prefix.length <= 2000 and consist only of lowercase English letters. word prefix At most calls will be made to , , and . 3 * 10^4 in total insert search startsWith Reasoning: is the classic data structure that is widely used. One of the most famous uses is text searching. Let’s take Google.com as an example. Trie Google’s example Have you ever noticed whenever you start typing a search phrase to a search bar you almost immediately get some suggestion from the searching system? I bet the answer is “Yes”. The Trie data structure makes it possible. Let’s add some words to Trie and see how it looks like this: Example of Trie with some words The Trie above contains words: Algorithm, Animation, Ant, Apache, Append, Apple, Application, Apricot. As you may notice we treat every word as a sequence of characters. Starting from the first character of each word we attach it to the root of the and move down till we reach the last character of each word. Trie Once we reached the end of a word we mark that last as the end of the word. I hope now it’s clear to you how it works in general. If you still struggle with it, I recommend you to read . Node Wikipedia’s article Solution: We are to implement Trie with the following method: https://gist.github.com/RakhmedovRS/a53ea510ad97088fdfd4829209d405b2 As we saw in the example of real we had to notice that as with any other data structure it consists of smaller pieces which are usually called . Let’s introduce this small part: Trie Tree Node https://gist.github.com/RakhmedovRS/bb2a188cd156565b692af1f5262d96a3 A few things we need to have a closer look at here: We have the boolean array which will tell us if we have particular characters in a particular node. boolean variable which answers just one question, whether or not the current node is the end of a word in our Trie. Last but not least TrieNode array stores child TrieNodes of the current TrieNode. chars isEnd children Let’s look at other methods, one by one: Method returns nothing and accepts word to insert into the Trie: void insert(String word) https://gist.github.com/RakhmedovRS/b460db4fd040a47ca33e8afc401af7c0 Starting from the root of the Trie we iterate through every char in provided word and create a new TrieNode every time if we don’t have one. At the last character in word, we mark TrieNode as isEnd. The next method in our list is which searches for a particular word in the Trie and returns a boolean value depending on whether or not the Trie contains it. As input, it takes a word. boolean search(String word) https://gist.github.com/RakhmedovRS/18bb68c4e83f3c602afa4a338e96fbc2 Here we do the same as in the previous method except for a few things. Iterate through every character in provided word and if we don’t have a child with the next character we return false. At the end of a word, we return the current node value of . isEnd Lastly method takes prefix and returns true if we have a prefix in our Trie if not we return false. boolean startsWith(String prefix) https://gist.github.com/RakhmedovRS/d25842ef37c339e6260ef50097713e84 This method does completely the same as the previous one except for only one thing. If we managed to iterate through the whole prefix we return true, because we’re looking for the prefix and not an entire word, otherwise we return false. As always at the end of the article, I prove the full source code of the problem https://gist.github.com/RakhmedovRS/cff7b0ea83d0a598c86c7b9aac834425 It has linear time and space complexity and has the following position among other people's solutions. Also published . here

How to Implement Trie (Prefix Tree) - Blind 75 LeetCode Questions

Cómo implementar Trie (Árbol de prefijos) - Preguntas ciegas de 75 LeetCode

In this post, we will look at prefix sums and how they can be used to solve a common coding problem, that is, calculating the sum of an array (segment). This article will use Java for the code samples but the concept should apply to most programming languages. Before looking into prefix sums, let’s look at the function below that calculates the sum of an array using a standard for loop. The function iterates the array and adds each value to a variable to get the sum: Array Segments Now for array segments, array segments can also be referred to as a of an array. Specifically a of an array. With some modifications, the previous function can be used to also calculate the array segment sum by adding starting and ending array indexes: slice continuous slice Let’s say we have an array with values and we want to get the sum of a segment starting from values . The sum should be . [ 10, 7, 22, 2, 13, 15, 6 ] 7 to 13 44 (7 + 22 + 2 + 13) Now, let’s use our modified function to calculate the sum of array segment providing the starting index for 7(index=1) and ending index for 13(index=4): Prefix sums Now for prefix sums, we can use prefix sums as an alternative approach to the same problem. Prefix sums is a simple yet powerful technique that we can use to easily calculate the sum of a segment or an array. It allows us to lookup the sum of an array segment or for the whole array in constant time, by introducing a reusable lookup array. Given the same array from above, its prefix sum should be like: Now that we know what prefix sums look like, let’s use it to calculate the sum of an array segment of the original array. Using the same example array segment as earlier, the segment that starts from index 1 and ends in index 4 that have the sum of 44. When using prefix sums, iterating each array value won’t be needed anymore, we only need two elements for the calculation and we can get those in constant time. We can get the two values using elements from prefix sums array in certain indexes. The first element is at the index of starting index of the array segment, in this case, it’s , which has the value of . The second element is at the index of the ending index of the array segment, in this case, it’s , so the final index is , which has the value of . Now that we have our two elements, we can subtract the first element to the second element to get the array segment sum which is . index 1 10 +1 index 4 + 1 5 54 44 (54 - 10) That is prefix sums, in theory, now let’s write some Java code to create a prefix sum of an array. The input would be the original array and the output would be an array containing values similar to the example above. There are slight variations on how one should build a prefix sum. In our example, we’re going with initializing it with an array size based from the original array size (n+1). Then each prefix sum value of will have a value of + in order for us to have a running sum for the original array: +1 prefixSum[i] prefixSum[i - 1] originalNums[i - 1] After creating our prefix sum, we can use it to look up the sum of an array segment(or whole) in constant O(1) time. Let’s build a helper function for that lookup to make our lives easier: Putting it all together, let’s use prefix sums to calculate the array segment sum for the same sample array above: In instances where different array segment sums are needed for the same array, prefix sums are most useful. The first approach would have been , where m is how many times we need to recalculate different array segments. With prefix sums, our time complexity is reduced to . O(n * m) O(n + m) End In this post, we learned what are prefix sums, how to implement them, and how they can be applied and used to calculate the sum of an array segment. Also published at: https://micogongob.com/array-segment-sum-using-prefix-sums

Prefix Sums and How They Can be Used to Solve Coding Problems

GraphQL’s concept spans from data store to client. What happens along the way? Tooling in the world has come a long way and spinning up an application is easier than ever. By stepping through each component, you’ll have a better understanding of GraphQL as a whole. GraphQL To follow along with this tutorial, clone this . It’s a bare-bones app using sessions to authenticate users, a battle tested and secure option for persisting user auth. fullstack example Our Stack Image from https://www.howtographql.com Looking at the image above from left to right, the first represents our client application built on (our GraphQL data cache) and . I’m using to build the client bundle. Apollo React Parcel Next, the “GraphQL Server” will be , a server based on which interfaces with Apollo and provides us with a lot of sensible defaults. graphql-yoga Express will stand between the server and the database as our data layer, similar to an ORM for writing and accessing data to and from our database. Prisma is open source and supports all of the major (the stack of pancake on the right of the image). Prisma databases Setup Start by installing some global packages. yarn global add prisma graphql-cli nodemon Create a file in our project folder, we’ll fill in the DB_URL variable once we deploy Prisma: .env APP_SECRET=mysecret123DB_URL= Next, create a then log into the Prisma CLI with so you can spin up free dev servers for your projects. Don’t worry, Prisma can be moved to the hardware of your choice at any time and won’t lock you in. Prisma account prisma login We’re going to generate our user models and deploy them to our test database. Inside of you’ll see we have one model, . When we deploy, Prisma will create the bindings based on this schema. Our in the root of our project will explain to Prisma how we want our setup deployed. Now, run: /database User .graphqlconfig.yml prisma deploy database Select “ , choose whichever region makes sense, enter a name like “ and set the stage as “ . Prisma will generate an endpoint like , drop it into your . Demo server” fullstack” dev” [https://us1.prisma.sh/_myusername-12345_/fullstack/dev](https://us1.prisma.sh/myusername-2acca9a/my-project/dev.) .env One last thing, Prisma will comment out your to: database/prisma.yml endpoint: #endpoint: ${env:DB_URL} [https://us1.prisma.sh/myusername-12345/fullstack/dev](https://us1.prisma.sh/myusername-2acca9a/my-project/dev.) ... So switch it back to: endpoint: ${env:DB_URL} ... How it’ll Work After installing dependencies with or fire it up your local server with and navigate to . The command will simultaneously run our server and frontend build. yarn install npm install npm run dev localhost:1234 dev Try Out Sign up and Log in! After a user is successfully created, it will kick you to the dashboard. Once you’re logged in, the protected routes won’t allow authenticated users to the or routes. Once logged out, you can’t go to . /signup /login /dashboard Try refreshing while logged in. On page load the app will make a request to check user’s authentication state. If authenticated, the page will then fetch the user’s data. The Backend Open you’ll see the server instantiated with . It takes a number of arguments: /src/index.js graphql-yoga GraphQLServer : This is our GraphQL schema. Inside the file you’ll see we’ve listed the queries and mutations that will be handled by our resolvers. Typedefs : These are the methods that do the work of logging in, fetching our user, etc. Their inputs and return values must match up with what’s defined in our typeDef’s . Resolvers schema.graphql this takes a function that we’ll use to set the database to point to our Prisma set up. Pass in the generated typeDefs from the as well as the endpoint and secret from our . Context: prisma deploy .env As mentioned above, is based on Express so we can use common packages like to handle our sessions. graphql-yoga express-session After we define our sessions implementation, we start the server with CORS settings that allow our frontend on (via parcel) to get our session cookies. localhost:1234 The Client Side Our front end is a barebones React application bundled up with Parcel. Starting in we set up the to connect to our server running on port and assign the client to our . client/index.jsx ApolloClient 4000 ApolloProvider In the component you’ll see we’re calling the query which checks if there’s a session on the backend. It’ll determine whether to show the links or . Header GET_AUTH_STATUS login / signup logout Further down in you’ll see protected routes for our and auth routes. I created a special route component, , which calls to decide whether to display the corresponding component. Even though we call our auth status query in a few different places, when you open “ ” in developer tools you’ll see that it is only requested once. This is because Apollo Cache handles the data between different components . index.jsx Dashboard ProtectedRoute GET_AUTH_STATUS Network automatically The component handles both our signup and login mutations. On successful login or signup, we need to update our because and mutations only return the User object. Instead of making another request for auth status, we’ll just update the status manually: Auth GET_AUTH_STATUS LOGIN SIGNUP <Mutationmutation={isSignup ? SIGNUP : LOGIN}variables={isSignup ? { email, name, password } : { email, password }} > update={(cache) => {cache.writeQuery({query: GET_AUTH_STATUS,data: {isLoggedIn: {status: true,__typename: 'AuthStatus',},},});}} Wrap Up Now’s a good time to dive in to GraphQL if you’ve been watching from the sidelines. The GraphQL eco-system has come a long way in the few years it’s been around. Each of the layers in the stack has matured enough that it’s relatively straightforward to build an app from top to bottom. Also, interest is on the rise. The most recent “ ” reflects this sentiment and we’ll only see more in the future. State of Javascript Well, can explain better than me, but suffice to say using server side sessions to save sensitive data is safer (and easy). Why not store JWTs in local storage or cookies? these articles Again, here’s a link to the example . repository

Piecing Together GraphQL

Primer on Large Language Model (LLM) Inference Optimizations: 3. Model Architecture Optimizations

Building Better React & Next.js Apps: Mistakes, Tips, and Best Practices

5 Useful Property Wrappers in Swift

Primer on Large Language Model (LLM) Inference Optimizations: 1. Background and Problem Formulation

Einführung in die Inferenzoptimierung von Large Language Models (LLM): 1. Hintergrund und Problemformulierung

Introducción a las optimizaciones de inferencia de modelos de lenguaje grandes (LLM): 1. Antecedentes y formulación del problema

Primer on Large Language Model (LLM) következtetések optimalizálása: 1. Háttér és probléma megfogalmazása

大規模言語モデル (LLM) 推論最適化入門: 1. 背景と問題の定式化

Үлкен тілдік үлгідегі (LLM) қорытындыны оңтайландырудағы праймер: 1. Фондық және мәселені тұжырымдау

Primer na ba optimisations ya inférence ya modèle ya monoko ya munene (LLM): 1. Formulation ya ba fond mpe ba problèmes

Том хэлний загвар (LLM) дүгнэлтийн оновчлолын талаархи праймер: 1. Үндэслэл ба асуудлын томъёолол

ठूला भाषा मोडेल (LLM) इन्फरेन्स अप्टिमाइजेसनमा प्राइमर: 1. पृष्ठभूमि र समस्या सूत्रीकरण

Primer on Large Language Model (LLM) Inference Optimizations: 1. Tlhamo ya Lemorago le Mathata

Учебник по оптимизации вывода большой языковой модели (LLM): 1. Предыстория и формулировка проблемы

Grundläggande om Large Language Model (LLM) slutledningsoptimeringar: 1. Bakgrund och problemformulering

Katta til modeli (LLM) xulosasini optimallashtirish bo'yicha primer: 1. Fon va muammoni shakllantirish

Stories, News & Mentions about PIEFI

Piefi’s Stories on HackerNoon