Loopis in the Enterprise Collaboration Industry

Loop

Introduction is a fundamental part of any programming language, and JavaScript is no exception. is a powerful tool that allows developers to iterate over collections of data, perform operations on each item, and make decisions based on certain conditions. JavaScript Loop JavaScript loop However, loops can quickly become a source of problems if not implemented properly. Poorly written loops can lead to performance issues, bugs, and code that is difficult to maintain. Whether you're a beginner or an experienced developer, writing efficient and effective loops can be a challenging task. In this comprehensive guide, we'll explore the best practices for writing that will help to take your code from noob to pro. We'll start with the basics, including choosing the right loop type and optimizing loop performance. JavaScript loops Then we'll dive into more advanced topics like using functional programming techniques and being careful with the asynchronous loops to avoid weird things in your code. Whether you're working with , , or other data structures, our tips and tricks will help you write clean, concise, and bug-free loops. arrays objects So if you're ready to master the art of , buckle up and let's dive in! JavaScript loop Choosing the Right Type of Loop When you are writing a loop in JavaScript, the First thing you need to do is choose the right type of loop. JavaScript offers several types of loops, including , , and , each with its own strengths and weaknesses. for loop while loop do-while loop Depending on the specific requirements of your code, one type of loop may be more efficient or more readable than another. Therefore, it's essential to consider the situation and choose the appropriate loop type to achieve the desired results. let's enlighten them one by one: Starting with the most popular one, The . It's the most common type of loop in JavaScript and is often used when you know how many times you want to execute a block of code. For loop For example, imagine you have an array of numbers and you want to calculate their sum: let numbers = [1, 2, 3, 4, 5] 
let sum = 0 
for (let i = 0; i < numbers.length; i++) { 
    sum += numbers[i] 
} 
console.log(sum) // Output: 15 Here, the is used to iterate over each element in the numbers array and add its value to the variable. Next , it is useful when you want to repeatedly execute a block of code until a certain condition is met. for loop sum While loop For example, imagine you want to generate random numbers between and until you get a number greater than : 0 1 0.5 let randomNumber = Math.random() 
while (randomNumber <= 0.5) { 
    randomNumber = Math.random() 
} 
console.log(randomNumber) // Output: a number greater than 0.5 In this case, the while loop repeatedly generates a new random number until it gets one that is greater than . 0.5 Next . It's similar to , but the difference is that a will always execute its block of code at least once, regardless of whether the condition is initially or . Do-while loop while loop do-while loop true false For example, imagine you want to ask the user to enter a number between and , and keep asking until they enter a valid number: 1 10 let number 
do { 
number = prompt('Enter a number between 1 and 10:') 
} while (number < 1 || number > 10) 
console.log(number) // Output: a number between 1 and 10 In this case, the repeatedly prompts the user to enter a number until they enter a number between and . do-while loop 1 10 So, as you can see, choosing the right type of loop depends on the specific task you are trying to accomplish. If you know how many times you want to execute a block of code, a may be the best choice. for loop If you want to repeatedly execute a block of code until a certain condition is met, or may be more appropriate. while loop do-while loop By selecting the right type of loop, you can make your code more efficient and easier to read. Use the Right Loop Control Statement After choosing the appropriate loop for your desired task, the Next thing you need to know is how to use the right loop control statement. There are two main loop control statements available in JavaScript: and . break continue These Loop control statements allow you to control the flow of a loop. is used to exit a loop completely when a certain condition is met. On the other hand, is used to skip the current iteration of the loop and move on to the next one. break continue For example, let's say you have an array of numbers and you want to find the first number in the array using a for loop. You can use to exit the loop once you find the first number: even break even const numbers = [1, 3, 2, 5, 4, 7, 6] 
for (let i = 0; i < numbers.length; i++) { 
    if (numbers[i] % 2 === 0) { 
        console.log(`The first even number is ${numbers[i]}`) 
        break 
    } 
} In this example, the loop will exit as soon as it finds the first number (which is ). Without the statement, the loop would continue iterating through the rest of the array. even 2 break On the other hand, let's say you want to print out all the numbers in the array, skipping over any numbers. You can use to skip the numbers: odd even continue even const numbers = [1, 3, 2, 5, 4, 7, 6] 
for (let i = 0; i < numbers.length; i++) { 
        if (numbers[i] % 2 === 0) { 
            continue 
        }         
    console.log(`Odd number: ${numbers[i]}`) 
} In this example, the loop will skip over the numbers and only print out the numbers (which are , , , and ). Without the continue statement, the loop would print out all the numbers in the array. odd 1 3 5 7 Now, we know how to choose the right loop for our task also when to use and . break continue Let's move to the next thing we need to think of when writing a loop, and this is optimizing the Loop performance. Optimizing the Loop Performance In normal situations, it may not create a big change in our code performance, but when we will work with a large number of data, optimizing the loop performance will become one of the most important things. Because Loop performance can have a significant impact on the overall performance of your JavaScript code. Therefore, it's essential to profile and optimize the performance of your loops. Here are some tips for optimizing loop performance: Avoiding Unnecessary Calculations One way to optimize loop performance is by avoiding unnecessary calculations. To understand the point, let's have a look at the example below: Suppose you have a loop that iterates over an . In that case, when you use a for loop to iterate over an array, the of the array is checked in each iteration to see if the loop should continue. array length For example, consider the following code: let arr = [1, 2, 3, 4, 5] 
for (let i = 0; i < arr.length; i++) { 
    console.log(arr[i]) 
} In each iteration of the loop, is checked to see if is less than the of the array. arr.length i length However, is a property of the array, and accessing it in each iteration can be expensive if the array is very large. arr.length Note: In JavaScript, an array is a special type of object that can store a collection of values of any data type. Every array has a property, which represents the number of elements in the array. This property is automatically updated as elements are added to or removed from the array. Since an array is an object, it can have properties and methods just like any other object. However, the property is unique to arrays and allows for easy access to the number of elements in the array. length length length To improve performance, you can cache the of the array outside the loop, like this: length let arr = [1, 2, 3, 4, 5] 
let len = arr.length // caching the length outside the loop 
for (let i = 0; i < len; i++) { 
    console.log(arr[i]) 
} By doing this, you avoid accessing the property of the array in each iteration, which can improve the performance of your code. This technique can be particularly useful when working with large arrays. length Note: It's worth noting that modern JavaScript engines like V8 are optimized to handle loops efficiently, and in some cases, caching the length of the array may not provide a significant performance boost. However, it's still a good practice to follow, especially when working with large arrays or in performance-critical code. Use Efficient Loops Another way to optimize loop performance is by using efficient loops. For example, is generally more efficient than the loop when iterating over arrays. for loop forEach Let's see the code snippet below to understand this: let arr = [1, 2, 3, 4, 5] // Using for loop for iterating over the array 
for (let i = 0, len = arr.length; i < len; i++) { 
    console.log(arr[i]) 
} In the above example, we are using a to iterate over the array. But the question is we could do the same using the . for loop arr forEach loop This is the better approach. Right? This topic is a bit complex and deserves a separate blog post to explain briefly. But one of the main reasons is when we use the loop, it creates a new function scope for every element in the array. forEach This means that for each element, a new function is created, and when the iteration is done, those functions are destroyed. This process is not an issue if the array is small. However, for larger arrays, it can slow down the loop's execution. On the other hand, creates a single function scope for the entire loop, which means that it only has to create and destroy a single function scope. for loop Also, provides a way to get control over the loop iteration using the and which simply doesn't provide. for loop break continue forEach loop That's why the is more optimized for looping over arrays. for loop Minimize DOM Manipulation In loops, it's important to minimize DOM manipulation as much as possible. Because, when working with the Document Object Model (DOM) in JavaScript, manipulating the DOM can be a time-consuming process. Each time you make a change to the DOM, the browser has to reflow and repaint the page, which can slow down your application, especially when working with large numbers of elements. For Example: // Inefficient DOM manipulation 
for (let i = 0; i < 1000; i++) { document.getElementById('myDiv').innerHTML += '<p>' + i + '</p>' 
} 
// More efficient DOM manipulation let output = '' 
for (let i = 0; i < 1000; i++) { 
    output += '<p>' + i + '</p>' 
} 
document.getElementById('myDiv').innerHTML = output In the given example, the first loop is inefficient because it manipulates the DOM on every iteration. The property of the element is updated with a new paragraph element on every iteration, resulting in a total of manipulations of the DOM. innerHTML myDiv 1000 On the other hand, the second loop is more efficient because it minimizes DOM manipulation. Instead of updating the DOM on every iteration, the loop concatenates a string of HTML to a variable called output. Once the loop is complete, the output string is used to update the property of the element just once, resulting in a single manipulation of the DOM. innerHTML myDiv Avoid Common Mistakes There are a few common mistakes that developers normally do, and you should be aware of and when working with loops in JavaScript: avoid common mistakes Modifying Loop Variables Inside the Loop can lead to unexpected results or errors. It's generally not a good practice to modify loop variables inside the loop. Instead, you should use a separate variable to store any values that you want to modify. Modifying loop variables inside the loop For example, consider the following loop: for (let i = 0; i < 10; i++) { 
    console.log(i); i++; // modifying i inside the loop 
} In this loop, i is being modified inside the loop, which can lead to unexpected results. Instead, you should use a separate variable to store any values that you want to modify, like this: for (let i = 0; i < 10; i++) { 
    console.log(i); 
    let modifiedValue = i + 1; // using a separate variable to modify i 
} Not Using Curly Braces It's possible to write a loop without curly braces, but it's generally not recommended. Without curly braces, it can be difficult to read and understand your code, and it can also lead to unexpected results or errors. For example, consider the following loop: for (let i = 0; i < 10; i++) 
console.log(i); This loop does not have curly braces, which can make it difficult to read and understand the code. It's better to always use curly braces, even for single-line statements: for (let i = 0; i < 10; i++) { 
    console.log(i); 
} Be Careful of Infinite Loop An is a loop that never stops. This can happen if you don't set up the correct exit condition or if the exit condition is never met. Infinite loops can cause your program to crash or hang, and they can be difficult to debug. infinite loop For example: Consider a loop that always increments the value of a variable but never checks if it has exceeded a certain value: let count = 0 
while (count < 10) { 
    console.log(count) 
} This code will result in an infinite loop because the count variable is never incremented beyond . 0 That's why you should always be careful about infinite loops. To avoid infinite loops, make sure you set up the correct exit condition and test it thoroughly. Off-by-One Errors occur when you use the wrong comparison operator or when you don't take into account the initial value of a loop variable. These errors can lead to incorrect results in your program or even crashes in some cases. Off-by-one errors For example, let's say you have an array with elements, and you want to loop through it and perform some operation on each element. 10 Here's how you might write the loop: const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; 
for (let i = 0; i < arr.length; i++) { 
    console.log(arr[i]); 
} This code will loop through all elements of the array and print their values to the console. However, what if you accidentally use the wrong comparison operator and write instead of ? 10 i <= arr.length i < arr.length const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; 
for (let i = 0; i <= arr.length; i++) { 
    console.log(arr[i]); 
} This code will result in an error because it will try to access an element that doesn't exist when is equal to . The loop will run a total of times instead of , and the final iteration will throw an error because is . off-by-one i arr.length 11 10 arr[10] undefined To avoid errors, always double-check your loop conditions to make sure you're using the correct comparison operator and taking into account the initial value of your loop variable. off-by-one By avoiding these , you can ensure that your loops are running as intended and reduce the chances of errors or crashes in your program. It's always a good idea to double-check your loops for these mistakes before running your code. common mistakes Use Recursion If Needed While loops are powerful, sometimes can be an even more elegant solution. recursion It is particularly useful for traversing hierarchical data structures, where it's not possible to know how many levels of nesting there are in advance. It can also lead to simpler and more elegant code than using nested loops, especially in cases where the depth of the structure is not known in advance. Note: It's important to use recursion carefully and avoid infinite recursion, which can lead to a stack overflow error. For example: Let's say you have a nested array of numbers, and you want to find the of all the numbers in the array, including the nested ones. One way to do this is by using recursion. Here's an example of how you could use recursion to find the : sum sum const nestedArray = [[1, 2, [3]], 4]; 
function sumArray(arr) { 
    let sum = 0; 
     for (let i = 0; i < arr.length; i++) { 
        if (Array.isArray(arr[i])) { 
            // If the element is an array, call the function recursively 
            sum += sumArray(arr[i]); } else { 
            // If the element is a number, add it to the sum 
            sum += arr[i]; 
        } 
      } 
return sum; 
} 
console.log(sumArray(nestedArray)); // Output: 10 In this example, we used because the input data, , is a data structure and the function need to traverse all the elements of the structure, regardless of the number of levels of nesting. Recursion nestedArray hierarchical allows the function to call itself repeatedly until it reaches the deepest level of nesting and returns a value that can be used to calculate the final . Recursion sum The function checks whether each element in the array is an array itself, and if it is, the function calls itself with that element as the input. This process repeats until all the nested arrays are traversed and the function reaches the deepest level of nesting, which is a number. At that point, the function returns the number to the previous level of recursion, which can then use that value to calculate the of all the elements in the current level of nesting. sum Conclusion is a fundamental part of any developer's toolbox, but they can be tricky to master. By following these best practices, you can write more efficient and effective loops that will help take your code to the next level. JavaScript loop Choose the right type of loop, use the right loop control statement, optimize loop performance, avoid common mistakes, and consider using recursion when appropriate. By keeping these tips in mind, you'll be well on your way to becoming a expert. JavaScript loop So take the time to evaluate and optimize your loops, and your code will be better for it. Visit my personal blog where I write more content like this: Roblog Other Posts of Mine: Javascript setTimeout method - All you need to know forEach method in JavaScript - A Comprehensive Guide Javascript hasOwnProperty: A Powerful Property Checking tool How to Round a Number to 2 Decimal Places in JavaScript How to Check if a String is Empty in JavaScript

JavaScript Loop: The Best Practices to Have the Optimal Performance

Testing has been a subject for developers for a while now, the agile Manifesto is more than 20 years old. Before that, we had eXtreme Programming (XP), and XP was the precursor for testing, meaning: having testable code as a practice, shifting left the need for writing the test first. This is not to say that, before, XP developers weren't testing applications - but writing test code became popular. Along those lines came different concerns, for example, any developer that follows TDD (Test Driven Development) or is familiar with that, follows the flow: write a failing test, make it pass with the simplest possible change, and then, refactor. Refactoring is a crucial step. Although practitioners have been practicing TDD for a few years, as there is no formal education, some questions come to mind: Should I use logic inside my tests? Should I use multiple assertions inside my tests? Here, we will focus on the assertions aspect of things as well as the logic inside the tests, using for loops for example. To For Loop or Not? If you think about that at first glance, having logic (of any kind  inside a test case) is something that looks like a smell. Diving a bit on the subject,  the mentions that tests should have no logic inside the test case. xUnit book For example, the classic logic is the if/else statement: if variable X is equal to true, I will assert that X is true, otherwise I will assert that Y is a string. With that, the test has two different reasons to fail. If you do that, you will have to spend some extra time understanding the logic behind the test and dedicate time to debugging which branch failed. In the end, if you have dynamic code in the test case, who will test the test? Therefore, we still have the question “Is it ok to use ?“ there.  Let’s start with some survey data, as it could provide insights into what approach practitioners follow. for loops in test cases The didn't get much attention but, from the ones that answered, it seems that developers don't care much about that (as interesting as it could sound, but in the comments, there are strong opinions). Twitter poll On the one hand, the results show just a minor difference. The "no", you should not use won the poll, but with a difference of 2.5% of the votes compared to “yes”. Not that much difference. for loops, On the other hand, If you take the GitHub repositories used in the , and navigate inside the source code, the probability of seeing a for loop inside the test case is not that high; at least, it wasn't for me. The pattern is the without for loops. TDD anti-patterns series AAA Last but Not Least, What About Multiple Assertions? There is a grey area in the comments on the tweet, but as far as the , there is no rule of having only one assertion per test case; the winner was “As many as I want“. poll data on Twitter goes Developers said that for the testing in place, if you are asserting multiple times the same behavior, why shouldn't you use multiple assertions? Elliotte Rusty Harold lists, as a best practice, to use one assertion per test method: https://youtu.be/fr1E9aVnBxw?t=938 All in all, assertions are a tricky subject to tackle, and it depends on the context in which the test was written, as such the takeaway from this section for me is the following: listen to your tests (Steve Freeman and Nat Pryce). Listening to the tests and the feedback it gives is an indicator of whether you are doing something good or not - good in the sense that it gives your ease of keeping the test running fast and gives the correct feedback when it fails.

The Never-Ending Debate: For Loops in Test Cases or Multiple Assertions

In this part of creating your programming language, we will implement loops. Please see the previous parts: Building Your Own Programming Language From Scratch Building Your Own Programming Language From Scratch: Part II - Dijkstra's Two-Stack Algorithm Build Your Own Programming Language Part III: Improving Lexical Analysis with Regex Lookaheads Building Your Own Programming Language From Scratch Part IV: Implementing Functions Building Your Own Programming Language From Scratch: Part V - Arrays The full source code is available over on . GitHub Our language will provide the following types of loops: loop - to iterate through a range: For loop - to iterate as long as a specified condition is true: While loop - to iterate through elements of arrays and structures: For-each (Iterable) 1 Lexical analysis In the first section, we will cover lexical analysis. It’s a process to divide the source code into language lexemes, such as keyword, identifier/variable, operator, etc. To make our lexical analysis work with loop constructions, we add the following lexemes: , , to the TokenType enum: Keyword loop in by package org.example.toylanguage.token;

...
public enum TokenType {
    ...
        Keyword("(if|elif|else|then|end|print|input|struct|fun|return|loop|in|by)(?=\\s|$)"),
    ...
} Then, in order to separate the lower and upper bounds of the For loop range, we add the two-dot lexeme: GroupDivider [.]{2} ...
public enum TokenType {
    ...
    GroupDivider("(\\[|\\]|\\,|\\{|}|[.]{2})"),
    ...
} And finally, if we don’t want the lexeme to catch the two-dot lexeme declared after the loop’s lower bound, we add a negative look ahead construction before the dot expression: Numeric GroupDivider (?![.]{2}) ...
public enum TokenType {
    ...
    Numeric("([-]?(?=[.]?[0-9])[0-9]*(?![.]{2})[.]?[0-9]*)"),
    ...
} 2 Syntax analysis Let’s move to the next section - the syntax analysis, which will convert the lexemes received from the previous step into the final statements following our language rules. As was said at the beginning, our language will support three types of loops: For, While and Iterable. Therefore, first we will declare the class, which will contain common execution process for all the loop types: AbstractLoopStatement package org.example.toylanguage.statement.loop;

public abstract class AbstractLoopStatement extends CompositeStatement {
    protected abstract void init();

    protected abstract boolean hasNext();

    protected abstract void preIncrement();

    protected abstract void postIncrement();
} Inside this class, we declare the following abstract methods, which can have different implementation for each loop type: - it will be invoked to perform initialization operations, like initializing a counter variable when a loop starts the execution. init() - It will be called before each iteration to define that we still have remaining items to iterate. hasNext() - It’s a prefix operation that will be called before each iteration. preIncrement() - It’s a postfix operation that will be called at the end of each iteration. postIncrement() Before creating the loop implementations, we complete the method by utilizing declared abstract methods. To start the execution, we invoke the method to initialize the loop state, but before that, we should open the new MemoryScope for the variables declared within the loop, as they shouldn’t be accessed after the loop ends. In the end of the execution, we release the earlier opened MemoryScope: Statement#execute() init() MemoryContext.newScope();

try {
	init();
} finally {
	MemoryContext.endScope();
} Next, to iterate a loop, we utilize the abstract method. Inside each iteration, we invoke the loop’s inner statements, defined within the inherited CompositeStatement class. When the iteration starts, we invoke the method to perform the prefix increment operations. At the end of each iteration, we call the method to perform the postfix increment operations accordingly: hasNext() preIncrement() postIncrement() while (hasNext()) {
	preIncrement();

	try {

		// execute inner statements
		for (Statement statement : getStatements2Execute()) {
			statement.execute();
		}
	} finally {
		postIncrement();
	}
} Next, to make sure that variables declared inside the loop statements are isolated from each iteration, we open the inner MemoryScope during the statements' execution. And finally, if our loop is defined inside the function and one of the loop’s inner statements contains a return statement, we should stop the iteration immediately because it’s a sign to exit a function. Therefore, we validate that the function's return statement hasn’t been called after each statement execution. The complete method: AbstractLoopStatement#execute() public abstract class AbstractLoopStatement extends CompositeStatement {
    ...

    @Override
    public void execute() {
        MemoryContext.newScope();
        try {

            init();

            while (hasNext()) {
                preIncrement();

                MemoryContext.newScope();

                try {

                    // execute inner statements
                    for (Statement statement : getStatements2Execute()) {
                        statement.execute();

                        if (ReturnContext.getScope().isInvoked())
                            return;

                    }
                } finally {
                    MemoryContext.endScope(); // release each iteration memory

                    
                    postIncrement();
                }

            }
        } finally {
            MemoryContext.endScope(); // release loop memory
        }
    }
} 2.1 For loop Let’s begin with the first For loop implementation. By our language design, it will contain the variable expression, the lower bound, the upper bound, and the step expression: package org.example.toylanguage.statement.loop;

@RequiredArgsConstructor
public class ForLoopStatement extends AbstractLoopStatement {
    private final VariableExpression variable;
    private final Expression lowerBound;
    private final Expression uppedBound;
    private final Expression step;
} Next, we implement the abstract methods. Within the first method, we assign the lower bound to the variable by evaluating an instance of AssignmentOperator, which accepts the expression as a first operand and the expression as a second operand: init() variable lowerBound ...
public class ForLoopStatement extends AbstractLoopStatement {
	...

	@Override
	protected void init() {
		new AssignmentOperator(variable, lowerBound)
				.evaluate();
	}
} Next, we override the . It should return a boolean value if we remaining have items. To make a compare operation, we create an instance of the LessThenOperator by passing the expression as a first operand, and the as a second operand. As a result, we expect to get the LogicalValue with boolean value inside it: hasNext() variable upperBound ...
public class ForLoopStatement extends AbstractLoopStatement {
    ...

	@Override
	protected boolean hasNext() {
		LessThanOperator hasNext = new LessThanOperator(variable, uppedBound);
		Value<?> value = hasNext.evaluate();
		return value instanceof LogicalValue && ((LogicalValue) value).getValue();
	}
} Lastly, to perform the increment operations for each iteration, we need to implement the and methods. The For loop should use the step increment only at the end of each iteration. Therefore, we perform the increment only within the method. To implement the increment operation, we create an instance of the AdditionOperator, which will sum up the value with the value, and assign the result to the expression again using an instance of the AssignmentOperator. If the step expression hasn’t been provided, we accumulate the NumericValue instance with the default value equal to : preIncrement() postIncrement() postIncrement() variable step variable 1.0 ...
public class ForLoopStatement extends AbstractLoopStatement {
	...

	@Override
	protected void preIncrement() {
	}

	@Override
	protected void postIncrement() {
		AdditionOperator stepOperator = new AdditionOperator(variable, Objects.requireNonNullElseGet(step, () -> new NumericValue(1.0)));
		new AssignmentOperator(variable, stepOperator)
				.evaluate();
	}
} 2.2 While loop The next loop implementation is the While loop. It’s more straightforward than the For loop, as we don’t need to perform addition and assignment operations at all. This operator will contain only the expression, which will only serve to calculate the result. The other overridden methods will be empty: hasNext hasNext() package org.example.toylanguage.statement.loop;

@RequiredArgsConstructor
public class WhileLoopStatement extends AbstractLoopStatement {
    private final Expression hasNext;

    @Override
    protected void init() {
    }

    @Override
    protected boolean hasNext() {
        Value<?> value = hasNext.evaluate();
        return value instanceof LogicalValue && ((LogicalValue) value).getValue();
    }

    @Override
    protected void preIncrement() {
    }

    @Override
    protected void postIncrement() {
    }
} 2.3 Iterable loop The last loop implementation is the Iterable loop. It will allow us to perform the for-each iterations with arrays and structures. First, we define the new Value implementation, which will override the interface and, accordingly, will provide us with the implementation: java.util.Iterable java.util.Iterator package org.example.toylanguage.expression.value;

public abstract class IterableValue<T> extends Value<T> implements Iterable<Value<?>> {
    public IterableValue(T value) {
        super(value);
    }
} Next, we extend the ArrayValue by implementing IterableValue and passing array values to the Iterator instance: package org.example.toylanguage.expression.value;

public class ArrayValue extends IterableValue<List<Value<?>>> {
    ...

    @Override
    public Iterator<Value<?>> iterator() {
        return getValue().iterator();
    }
} And we do the same extension for StructureValue as well. For now, we will iterate only the structure’s values. Later, we can introduce the dictionary data type to operate with key-value types: package org.example.toylanguage.expression.value;

public class StructureValue extends IterableValue<Map<String, Value<?>>> {
    ...

    @Override
    public Iterator<Value<?>> iterator() {
        return getValue().values().iterator();
    }
} Now we have the two IterableValue implementations which can provide us with the Iterator instance, we can complete the Iterable loop with the corresponding implementation. It will contain the expression and the expression. Also, we declare an auxiliary non-final field that will be used to iterate the loop: variable iterable Iterator<Value<?> package org.example.toylanguage.expression.value;

@RequiredArgsConstructor
public class IterableLoopStatement extends AbstractLoopStatement {
    private final VariableExpression variable;
    private final Expression iterableExpression;

    private Iterator<Value<?>> iterator;
} Next, we override and resolve the abstract methods. Inside the method, we initialize the field using the IterableValue’s method: init() iterator iterator() ...
public class IterableLoopStatement extends AbstractLoopStatement {
    ...

	@Override
	protected void init() {
		Value<?> value = iterableExpression.evaluate();
		if (!(value instanceof IterableValue))
			throw new ExecutionException(String.format("Unable to loop non IterableValue `%s`", value));
		this.iterator = ((IterableValue<?>) value).iterator();
	}
} The method will utilize the implementation. Lastly, we should perform the prefix increment operation to know the value that is currently being iterated. Within , we create an instance of the AssignmentOperator, which will accept the as a first operand, and the value received from the iterator as a second operand: hasNext() Iterator#hasNext() preIncrement() variable ...
public class IterableLoopStatement extends AbstractLoopStatement {
    ...

	@Override
	protected boolean hasNext() {
		return iterator.hasNext();
	}

	@Override
	protected void preIncrement() {
		Value<?> next = iterator.next();
		new AssignmentOperator(variable, next)
				.evaluate();
	}

	@Override
	protected void postIncrement() {
	}

} 2.4 StatementParser To make the loop statements work, we need to map the loop lexemes to the defined statements using the StatementParser class. All the loops defined by the language grammar start with the keyword. Therefore, inside the parseExpression() method, we add a new case for the corresponding Keyword lexeme: loop loop package org.example.toylanguage;

public class StatementParser {
	...

	private Statement parseExpression() {
		Token token = tokens.next(TokenType.Keyword, TokenType.Variable, TokenType.Operator);
		switch (token.getType()) {
			case Variable:
			case Operator:
                ...
			case Keyword:
				switch (token.getValue()) {
					case "print":
                        ...
					case "input":
                        ...
					case "if":
                        ...
					case "struct":
                        ...
					case "fun":
                        ...
					case "return":
                        ...
					case "loop":
                        ...
				}
			default:
                ...
		}
	}
} After the Keyword, we read the next expression using the Dijkstra Two-Stack algorithm defined within the ExpressionReader class. If we read the For or the Iterable loop, we expect this expression to be only a variable. If we read the While loop, this expression will act as a loop condition, which can be an instance of any Expression implementation, including operator or function invocation. Therefore, we split the execution. In case the expression is the VariableExpression instance and the next lexeme is the Keyword, we continue to read the For and Iterable loop. In the negative case, we build the WhileLoopStatement using the condition expression: loop in case "loop": {
    Expression loopExpression = new ExpressionReader().readExpression();

    AbstractLoopStatement loopStatement;
    if (loopExpression instanceof VariableExpression && tokens.peek(TokenType.Keyword, "in")) {
        // loop <variable> in <bounds>
    } else {
        // loop <condition>
        loopStatement = new WhileLoopStatement(loopExpression);
    } Inside the For and Iterable loop clause, we skip the next Keyword lexeme, and then read the following bounds expression. This expression can be an instance of any Expression implementation which can be evaluated to the lower bound value or IterableValue only when the code will be executed. To define which loop type it is, we can rely on the next lexeme. In the case of the For loop, after the lower bound expression, we expect to read the two-dot GroupDivider as a spliterator for lower and upper bounds. In the negative condition, we build the IterableLoopStatement: in if (loopExpression instanceof VariableExpression && tokens.peek(TokenType.Keyword, "in")) {

    // loop <variable> in <bounds>
    VariableExpression variable = (VariableExpression) loopExpression;
    tokens.next(TokenType.Keyword, "in");
    Expression bounds = new ExpressionReader().readExpression();

    if (tokens.peek(TokenType.GroupDivider, "..")) {
        // loop <variable> in <lower_bound>..<upper_bound>
    } else {
        // loop <variable> in <iterable>
        loopStatement = new IterableLoopStatement(variable, bounds);
    }
} To build the last For loop statement, we skip the two-dot GroupDivider and read the upper bound expression. In our language grammar, for the For loop, we can define the step expression with the keyword. Therefore, if the next expression is the lexeme, we read the following step expression. At the end, we build an instance of the ForLoopStatement: by by if (tokens.peek(TokenType.GroupDivider, "..")) {
    // loop <variable> in <lower_bound>..<upper_bound>
    tokens.next(TokenType.GroupDivider, "..");
    Expression upperBound = new ExpressionReader().readExpression();

    Expression step = null;
    if (tokens.peek(TokenType.Keyword, "by")) {
        // loop <variable> in <lower_bound>..<upper_bound> by <step>
        tokens.next(TokenType.Keyword, "by");
        step = new ExpressionReader().readExpression();
    }

    loopStatement = new ForLoopStatement(variable, bounds, upperBound, step);
} We have read every loop type declaration. Finally, we can read the body of the loop. To gather all internal statements, we invoke the recursive method, which will return an instance of the Statement interface. We should stop the process when we reach the finalizing lexeme: StatementParser#parseExpression() end while (!tokens.peek(TokenType.Keyword, "end")) {
    Statement statement = parseExpression();
    loopStatement.addStatement(statement);
} At the end, we skip this keyword and return the loopStatement. The complete clause: end loop case "loop": {
    Expression loopExpression = new ExpressionReader().readExpression();
    AbstractLoopStatement loopStatement;

    if (loopExpression instanceof VariableExpression && tokens.peek(TokenType.Keyword, "in")) {
        // loop <variable> in <bounds>
        VariableExpression variable = (VariableExpression) loopExpression;
        tokens.next(TokenType.Keyword, "in");
        Expression bounds = new ExpressionReader().readExpression();

        if (tokens.peek(TokenType.GroupDivider, "..")) {
            // loop <variable> in <lower_bound>..<upper_bound>
            tokens.next(TokenType.GroupDivider, "..");
            Expression upperBound = new ExpressionReader().readExpression();

            Expression step = null;
            if (tokens.peek(TokenType.Keyword, "by")) {
                // loop <variable> in <lower_bound>..<upper_bound> by <step>
                tokens.next(TokenType.Keyword, "by");
                step = new ExpressionReader().readExpression();
            }

            loopStatement = new ForLoopStatement(variable, bounds, upperBound, step);

        } else {
            // loop <variable> in <iterable>
            loopStatement = new IterableLoopStatement(variable, bounds);
        }

    } else {
        // loop <condition>
        loopStatement = new WhileLoopStatement(loopExpression);
    }

    while (!tokens.peek(TokenType.Keyword, "end")) {
        Statement statement = parseExpression();
        loopStatement.addStatement(statement);
    }

    tokens.next(TokenType.Keyword, "end");

    return loopStatement;
} 3 Tests We have finished embedding loops in both lexical and syntax analyzers. Now we should be able to perform For, While and Iterable loops. Let’s create and test a more real task - the bubble sort algorithm: fun bubble_sort [ arr, n ]
    loop i in 0..n - 1
        loop j in 0..n - i - 1
            if arr{j+1} < arr{j} then
                temp = arr{j}
                arr{j} = arr{j + 1}
                arr{j + 1} = temp
            end
       end
    end
end

fun is_sorted [ arr, n ]
    loop i in 0..n - 1
        if arr{i} > arr{i+1} then
            return false
        end
    end
    return true
end

arr = {}
arr_len = 20
loop i in 0..arr_len by 1
    arr << i * 117 % 17 - 1
end

print arr # [-1, 14, 12, 10, 8, 6, 4, 2, 0, 15, 13, 11, 9, 7, 5, 3, 1, -1, 14, 12]
print is_sorted [ arr, arr_len ] # false

bubble_sort [ arr, arr_len ]
print arr # [-1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 12, 13, 14, 14, 15]
print is_sorted [ arr, arr_len ] # true

Building Your Own Programming Language From Scratch: Part VI - Loops

There are situations, when during the development of an application, there is a need to create a sequence of data, such as a sequence of numbers that can serve as identifiers. Some programming languages have special built-in functions that can generate such data, but JavaScript does not. range In this article, we will look at how to implement a similar function in JavaScript and how to use it in different situations. The function in JavaScript can be useful in cases where you need to generate a sequence of integers or other data types with a certain amount of spacing between values. Also, as an example, you can give a sequence of dates, with an interval of a day, a week, or a month. range However, let’s begin with an easier example and use the function to generate a sequence of numbers from 1 to 10 like this: range range(1, 10); // [1, 2, 3, ..., 10] Below you can see one of the implementations of the range function to generate a sequence of numbers: function range(start, end) {
  const seq = [];

  for (let i = start; i <= end; i++) {
    seq.push(i);
  }

  return seq;
} In this example above, the function creates a new array and fills it with integers using a loop. After the array is filled, the function returns it. range seq for You can change the step between elements of a sequence by adding a third argument to the function: function range(start, end, step) {
  const seq = [];

  for (let i = start; i <= end; i += step) {
    seq.push(i);
  }

  return seq;
}

range(1, 10, 2); // [1, 3, 5, 7, 9] Here, the function returns an array of odd numbers from 1 to 10 since the initial value is set to 1 and the step is set to 2. You can also change the direction of the sequence generation by specifying a negative step like this: range function range(start, end, step) {
  const seq = [];

  for (let i = start; i >= end; i += step) {
    seq.push(i);
  }

  return seq;
}

range(10, 1, -2); // [10, 8, 6, 4, 2] Note that the function only works with integers. If you need to generate a sequence of fractional numbers, then you need to write an appropriate function or use other ways to generate a sequence with fractional numbers. range The function can be used to create a sequence of strings, such as a sequence of letters from the alphabet: range function range(start, end, step = 1) {
  const start = start.charCodeAt(0);
  const end = end.charCodeAt(0);

  const seq = [];
  for (let i = start; i <= end; i += step) {
    seq.push(String.fromCharCode(i));
  }

  return seq;
}

range('a', 'z'); // ['a', 'b', 'c', ..., 'z'] In this example, we initiate the method on the start and end value of the sequence. The method returns the numeric value for the character at the specified index. charCodeAt charCodeAt Next, using the loop, iterate over the elements of the sequence and set the values using the method. The static method returns a string created from the specified character code. After the array is filled, the function returns it. for String.fromCharCode() String.fromCharCode() In the previous examples, the function generates either a sequence of integers or strings from start to end values with a given step. However, you can also create a function with more complex logic that will work on different data types at the same time. range range To summarize, we have analyzed the function in JavaScript, which allows you to generate a sequence of numbers and strings with a certain step. range We learned how to implement such a function with a loop and how to use it in various situations. Use the function to simplify your code and speed up development. for range

Function Range in JavaScript: Generating a Sequence of Data

Like a lot of people, I was shocked by TerraUSD’s (UST’s) de-pegging this week. What happened? Just to be clear, I wasn’t surprised by the market crash. The entire market is down right now, though bitcoin is . That’s just business as usual. back over $30,000 What precipitated the crash is the Fed more than it’s done in two decades. The market responded. In other words, institutional investors pulled their money out of crypto and slid them into safer investments to ride out the tide. Right now, there is a lot of FUD around future rate hikes. The Fed is expected to issue several more this year in order to combat inflation. Many people . raising the interest rates fear a recession I fear no recession. That doesn’t mean it won’t happen. It probably will, but it will happen because people fear it and act on that fear. I’ve got better things to do. But a recession could be on the way, and when recessions show up at the bus stop, a lot of people jump off the bus. The problem is, you still must get to your destination. So, you choose to walk, which takes you longer to get there, instead of riding the bus because you don’t want that wicked recession sitting next to you. The reality is, that markets move in waves. Ups and downs. All the time. Sometimes those ups and downs are extreme. The key is not to get off the bus but to manage the time you spend on the bus. Read a book! Don’t take a nap. There’s my rant. Back to LUNA/UST. UST , de-pegging from the dollar. A stablecoin isn’t supposed to do that. But the way LUNA/UST works is a bit like a . fell to 30 cents hotwife Stablecoins and UST’s Weird Sex Habit A stablecoin is a cryptocurrency pegged to a more stable currency, like the U.S. dollar. Both Tether (USDT) and USD Coin (USDC) maintain their pegs to the U.S. dollar because they are backed by the dollar. It’s the same principle the U.S. used to operate on in pegging the dollar to the gold standard. Back the currency by the precious metal and the currency will maintain its value longer. As long as the precious metal is stable, the currency will be stable. UST falls into the category of algorithmic stablecoins, a term that means it is not backed by a stable currency but maintains its peg through a clever coding mechanism. In UST’s case, to create one UST, users have to burn LUNA. As more people buy UST, more LUNA is burned making it more scarce and driving up the value of LUNA left in circulation. To incentivize users to burn LUNA and create more UST, backers created Anchor Protocol, a decentralized lending mechanism that paid who staked their UST. Until last weekend, about was staked on Anchor Protocol. 20 percent to people 70 percent of all UST To maintain its peg to the U.S. dollar, market players burn either UST or LUNA. If UST falls below $1, users burn LUNA and receive more UST, which drives up the price of UST. If UST goes above $1, they trade UST for LUNA, and the price of UST goes down. That works because people are predictable, right? Well, last weekend, likely in response to the interest rate hike, $2 billion of UST on the Anchor Protocol was unstaked and millions of it sold immediately. Market players rushed to take advantage of the LUNA/UST arbitrage. Because UST fell to 91 cents, they could exchange 90 cents of UST for $1 in LUNA. Big profit opportunity! But, because only $100 million worth of UST can be burned in one day, the blockchain reached its freaking limit. Terra Luna’s hotwife ran out of lovers. There is a theory floating around that the Terra/LUNA/UST ecosystem suffered a malicious attack that caused the price of LUNA to drop to and UST to plummet like an airborne soldier whose parachute has collapsed. It’s now down to . It could fall even further. below 1 cent 17 cents Terra has a plan to . The woman he fell in love with. The virgin cheerleader he courted in high school and who gave him his first oral experience when he didn’t even know such a thing was a thing. But at this point, the virgin has been devirginized and will never be a virgin again. Nor will she be the sweet, chaste lover he married. Once a hotwife, even after a lengthy cooldown, she’ll always be known as a hotwife. get his hotwife back again How This Little Fiasco Affected Me I don’t care about market crashes. Markets move up, markets move down. I plan for that. What I don’t plan for is another man’s wife knocking on my door and asking me if I want to bop the sock hop girl who danced with every jock at the prom. Unfortunately, I got a knock on the door and wasn’t told the sock hop girl was somebody else’s wife. As it turns out, I’ve been playing around on Loop Market’s Community board for about three years—back then, it was called Trybe. Last year, Trybe moved to the Terra blockchain and rebranded to Loop. When that happened, all my Trybe was transferred to LOOPR, the community token. Each month, I receive an airdrop of LOOP based on how many LOOPR I have in my account (and, at this point, I’m no slouch). I don’t cash it out. Instead, I’ve kept it in my account so I could play around on the Loop DEX to learn how their staking, liquidity pool, and yield farm work. I haven’t been impressed. For starters, in order to participate in any of those, one must hold UST. That’s because Terra’s gas fees, as inexpensive as they are, must be paid in UST. I didn’t want to buy UST. To get around spending money, I started transferring AMPL I earned on Publish0x to Kucoin, converting it to UST, and depositing it into my Terra wallet. I used it to pay for gas fees. I also used it as a trading pair in Loop’s liquidity pool and yield farm. But I quickly learned that I wasn’t going to earn much if I didn’t have more UST. I had thousands of LOOP, but just a few UST, and you can only farm or pool an amount of LOOP equal to the UST you put in the pool or farm. I converted some LOOP to UST. Just as I was beginning to get comfortable with the liquidity pool and yield farm, the market crashed and LUNA’s hotwife told me she was married. Damn! Suddenly, I realized I was an adulterer and breaking one of God’s commandments. I felt like Samson. I felt like King David after Nathan the prophet called him out in a public way. I felt like Solomon after realizing that all my wealth, wisdom, and thousands of concubines couldn’t satisfy my thirst for more. I’d been had. Now I sit with almost 2,000 LOOP in a liquidity pool, along with some UST, virtually useless. I have another 95 UST sitting in my Loop account waiting to be plundered by the Queen of Sheba. At this point, I feel like giving up on Loop Markets completely. It would be pointless to cash out my LOOP and UST. It’s not that much to speak of. On the other hand, if I don’t, UST could fall until it hits zero, like a drug addict with a death wish. I’ve invested no money. Everything I have is what I’ve earned blogging on the platforms, either Loop or Publish0x. The bright side: It doesn’t help that I also have frequent technical challenges uploading my posts to Loop. Wednesday this week, the platform wouldn’t upload an image. I didn’t post my usual newsletter because the image never loaded. On Telegram, their tech support is always the same - refresh your browser, clear your cache, and try again. The last time I did that, I got locked out of my Facebook account and had to start another one. I had more than 5,000 connections. I was hoping Loop Markets was going someplace. It’s been one of my best earners in crypto social media, but that means nothing when the value of its tokens is worth nothing. If today’s post doesn’t load, I think I’ll count it all as a loss and move on. What do you think? ? Should I stay or should I go Also published here

Why I no Longer Have Respect for LUNA/UST 

This blog post is about comparing the running times of the most commonly used ways to loop through an array in JavaScript in order to see which one is the most efficient. The tests The idea is very simple. I compared the running times of five very common ways ( , , , , ) of looping through an array using an array of 100 values and another array of 10 million values. The code used was run in a Node.js runtime environment version 16.14.0 inside a Ubuntu 20 laptop. map forEach for while do while Testing the .map() method Here is the code used for an array of 100 values const arraySize = 100;

const arrayToTest = Array(arraySize)
  .fill(0)
  .map((_, i) => i);

// small code to warm up the process used 
for (let index = 0; index < arrayToTest; index++) {
  index * index + Math.sqrt(item);
}

console.time("map");
arrayToTest.map((item, index) => {
  return (arrayToTest[index] = item * item + Math.sqrt(item));
});
console.timeEnd("map"); Here is the result I got from the above code : map: 0.150ms For an array of 10 million values, I used the same code as above while just replacing the constant with 10000000. Here is the result I got : arraySize map: 1865.563ms Testing the .forEach() method Here is the code used for an array of 100 values const arraySize = 100;

const arrayToTest = Array(arraySize)
  .fill(0)
  .map((_, i) => i);

// small code to warm up the process used 
for (let index = 0; index < arrayToTest; index++) {
  index * index + Math.sqrt(item);
}

console.time("forEach");
arrayToTest.forEach((item, index) => {
  return (arrayToTest[index] = item * item + Math.sqrt(item));
});
console.timeEnd("forEach"); Here is the result I got from the above code : forEach: 0.137ms For an array of 10 million values, I used the same code as above while just replacing the constant with 10000000. Here is the result I got : arraySize forEach: 1201.149ms Testing the for loop Here is the code used for an array of 100 values const arraySize = 100;

const arrayToTest = Array(arraySize)
  .fill(0)
  .map((_, i) => i);

// small code to warm up the process used 
for (let index = 0; index < arrayToTest; index++) {
  index * index + Math.sqrt(item);
}

console.time("for");
for (let i = 0; i < arrayToTest.length; i++) {
  arrayToTest[i] = arrayToTest[i] * arrayToTest[i] + Math.sqrt(arrayToTest[i]);
}
console.timeEnd("for"); Here is the result I got from the above code : for: 0.127ms For an array of 10 million values, I used the same code as above while just replacing the constant with 10000000. Here is the result I got : arraySize for: 109.778ms Testing the while loop Here is the code used for an array of 100 values const arraySize = 100;

const arrayToTest = Array(arraySize)
  .fill(0)
  .map((_, i) => i);

// small code to warm up the process used 
for (let index = 0; index < arrayToTest; index++) {
  index * index + Math.sqrt(item);
}

console.time("while");
let i = 0;
while (i < arrayToTest.length) {
  arrayToTest[i] =
    arrayToTest[i] * arrayToTest[i] + Math.sqrt(arrayToTest[i]);
  i++;
}
console.timeEnd("while"); Here is the result I got from the above code : while: 0.294ms For an array of 10 million values, I used the same code as above while just replacing the constant with 10000000. Here is the result I got : arraySize while: 108.698ms Testing the do…while loop Here is the code used for an array of 100 values const arraySize = 100;

const arrayToTest = Array(arraySize)
  .fill(0)
  .map((_, i) => i);

// small code to warm up the process used 
for (let index = 0; index < arrayToTest; index++) {
  index * index + Math.sqrt(item);
}

console.time("do while");
let i = 0;
do {
  arrayToTest[i] = arrayToTest[i] * arrayToTest[i] + Math.sqrt(arrayToTest[i]);
  i++;
} while (i < arrayToTest.length);
console.timeEnd("do while"); Here is the result I got from the above code : do while: 0.118ms For an array of 10 million values, I used the same code as above while just replacing the constant with 10000000. Here is the result I got : arraySize do while: 124.894ms Summary For the array with 100 values, here are the results I got map: 0.150ms
forEach: 0.137ms
for: 0.127ms
while: 0.120ms
do while: 0.118ms For the second array with 10 millions values, here are the results I got map: 1865.563ms
forEach: 1201.149ms
for: 109.778ms
while: 145.869ms
do while: 124.894ms In small arrays, the optimization work done by the V8 engine while compiling our JavaScript code is good enough and the running times of the methods tested above are very close. In big arrays, and take much more time (more than eleven times as shown in this example) than the other methods. One factor causing this additional time is invoking callback functions which consume more memory and therefore add more performance costs in big arrays. or have very close running times in big arrays and it is difficult to say, at least from the examples above, that one is radically faster than the others in big arrays. Additional tests are needed in that sense to determine which method is the most efficient. map() forEach() for while do while Conclusion Whenever we have to write a loop, it is important to consider what solution works best. In relatively small arrays, the optimization work done by the V8 engine is good enough. However, when processing a large amount of data, then the performance cost might be important if we don’t carefully choose the most efficient solution and the running time then might be, eleven times more in some cases as shown in the results above. Performance is not the only thing that matters. Code readability and maintainability are also very important when writing code in any programming language. You can check I wrote on how to write clean code for JavaScript developers. a previous article If this post was helpful to you, please don't hesitate to share it. You can also follow if you would like to see more content related to web programming. my Twitter account

Performance Tests on Common JavaScript Array Methods

Design, Manufacturing and Open-Loop Control of a Soft Pneumatic Arm: Conclusions

Authors:
(1) Jorge Francisco Garcia-Samartın, Centro de Automatica y Robotica (UPM-CSIC), Universidad Politecnica de Madrid — Consejo Superior de Investigaciones Cientıficas, Jose Gutierrez Abascal 2, 28006 Madrid, Spain (jorge.gsamartin@upm.es);
(2) Adrian Rieker, Centro de Automatica y Robotica (UPM-CSIC), Universidad Politecnica de Madrid — Consejo Superior de Investigaciones Cientıficas, Jose Gutierrez Abascal 2, 28006 Madrid, Spain;
(3) Antonio Barrientos, Centro de Automatica y Robotica (UPM-CSIC), Universidad Politecnica de Madrid — Consejo Superior de Investigaciones Cientıficas, Jose Gutierrez Abascal 2, 28006 Madrid, Spain. Table of Links Abstract and 1 Introduction 2 Related Works 2.1 Pneumatic Actuation 2.2 Pneumatic Arms 2.3 Control of Soft Robots 3 PAUL: Design and Manufacturing 3.1 Robot Design 3.2 Material Selection 3.3 Manufacturing 3.4 Actuation Bank 4 Data Acquisition and Open-Loop Control 4.1 Hardware Setup 4.2 Vision Capture System 4.3 Dataset Generation: Table-Based Models 4.4 Open-Loop Control 5 Results 5.1 Final PAUL version 5.2 Workspace Analysis 5.3 Performance of the Table-Based Models 5.4 Bending Experiments 5.5 Weight Carrying Experiments 6 Conclusions Funding Information A. Conducted Experiments and References 5.4 Bending Experiments The first experiment consisted of analysing the deflection of a segment versus swelling time. For this purpose, one of the bladders was inflated continuously, in intervals of 100 ms. For each time, PAUL end coord where x0 and y0 denote initial position of PAUL end. Since the weight of the subsequent modules influences the behaviour of the first segment, the experiment was repeated by placing first one and then two additional segments. The results are shown in Figure 18. As can be seen, PAUL is capable of bending up to 40◦ to its vertical axis and the addition of new segments does not cause any noticeable decrease in its bending capacity. Although it remains far from the 80◦ of [28] or the 70◦ of [32], Pneunet segments and therefore more flexible, this is an acceptable bending capacity. Moreover, the fact that it does not substantially lose its bending capacity by adding segments makes it possible to concatenate bending movements and thus overcome obstacles that a rigid robot would not be able to overcome. In conjunction with this, a validation test was proposed whose purpose was to demonstrate PAUL’s ability to flex thanks to its deformable geometry. The aim was to point points in lateral planes. The results of this experiment are shown in Figure 19. The images, extracted from the video of Appendix A, show how the manipulator can adopt different shapes, is able to bend up to 40◦ and adapt, in case of obstacles, to a wide variety of geometries, which undoubtedly makes PAUL a fundamental ally in inspection and exploration operations in very cluttered environments. This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. Authors: (1) Jorge Francisco Garcia-Samartın, Centro de Automatica y Robotica (UPM-CSIC), Universidad Politecnica de Madrid — Consejo Superior de Investigaciones Cientıficas, Jose Gutierrez Abascal 2, 28006 Madrid, Spain (jorge.gsamartin@upm.es); (2) Adrian Rieker, Centro de Automatica y Robotica (UPM-CSIC), Universidad Politecnica de Madrid — Consejo Superior de Investigaciones Cientıficas, Jose Gutierrez Abascal 2, 28006 Madrid, Spain; (3) Antonio Barrientos, Centro de Automatica y Robotica (UPM-CSIC), Universidad Politecnica de Madrid — Consejo Superior de Investigaciones Cientıficas, Jose Gutierrez Abascal 2, 28006 Madrid, Spain. Authors: Authors: (1) Jorge Francisco Garcia-Samartın, Centro de Automatica y Robotica (UPM-CSIC), Universidad Politecnica de Madrid — Consejo Superior de Investigaciones Cientıficas, Jose Gutierrez Abascal 2, 28006 Madrid, Spain (jorge.gsamartin@upm.es); (2) Adrian Rieker, Centro de Automatica y Robotica (UPM-CSIC), Universidad Politecnica de Madrid — Consejo Superior de Investigaciones Cientıficas, Jose Gutierrez Abascal 2, 28006 Madrid, Spain; (3) Antonio Barrientos, Centro de Automatica y Robotica (UPM-CSIC), Universidad Politecnica de Madrid — Consejo Superior de Investigaciones Cientıficas, Jose Gutierrez Abascal 2, 28006 Madrid, Spain. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Related Works 2.1 Pneumatic Actuation 2.1 Pneumatic Actuation 2.2 Pneumatic Arms 2.2 Pneumatic Arms 2.3 Control of Soft Robots 2.3 Control of Soft Robots 3 PAUL: Design and Manufacturing 3.1 Robot Design 3.1 Robot Design 3.2 Material Selection 3.2 Material Selection 3.3 Manufacturing 3.3 Manufacturing 3.4 Actuation Bank 3.4 Actuation Bank 4 Data Acquisition and Open-Loop Control 4.1 Hardware Setup 4.1 Hardware Setup 4.2 Vision Capture System 4.2 Vision Capture System 4.3 Dataset Generation: Table-Based Models 4.3 Dataset Generation: Table-Based Models 4.4 Open-Loop Control 4.4 Open-Loop Control 5 Results 5.1 Final PAUL version 5.1 Final PAUL version 5.2 Workspace Analysis 5.2 Workspace Analysis 5.3 Performance of the Table-Based Models 5.3 Performance of the Table-Based Models 5.4 Bending Experiments 5.4 Bending Experiments 5.5 Weight Carrying Experiments 5.5 Weight Carrying Experiments 6 Conclusions 6 Conclusions Funding Information Funding Information A. Conducted Experiments and References A. Conducted Experiments and References 5.4 Bending Experiments The first experiment consisted of analysing the deflection of a segment versus swelling time. For this purpose, one of the bladders was inflated continuously, in intervals of 100 ms. For each time, PAUL end coord where x0 and y0 denote initial position of PAUL end. Since the weight of the subsequent modules influences the behaviour of the first segment, the experiment was repeated by placing first one and then two additional segments. The results are shown in Figure 18. As can be seen, PAUL is capable of bending up to 40◦ to its vertical axis and the addition of new segments does not cause any noticeable decrease in its bending capacity. Although it remains far from the 80◦ of [28] or the 70◦ of [32], Pneunet segments and therefore more flexible, this is an acceptable bending capacity. Moreover, the fact that it does not substantially lose its bending capacity by adding segments makes it possible to concatenate bending movements and thus overcome obstacles that a rigid robot would not be able to overcome. In conjunction with this, a validation test was proposed whose purpose was to demonstrate PAUL’s ability to flex thanks to its deformable geometry. The aim was to point points in lateral planes. The results of this experiment are shown in Figure 19. The images, extracted from the video of Appendix A, show how the manipulator can adopt different shapes, is able to bend up to 40◦ and adapt, in case of obstacles, to a wide variety of geometries, which undoubtedly makes PAUL a fundamental ally in inspection and exploration operations in very cluttered environments. This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. available on arxiv

Loop

heyloop.ai

-- employees

Since n.d.

COMPANY RANKING

LOOP

EVERGREEN INDEX #7979

Loop WIKI

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

Loop

heyloop.ai

-- employees

Since n.d.

COMPANY RANKING

LOOP

EVERGREEN INDEX #7979

RELATED COMPANIESRANK

STORIES ABOUT LOOP

Loop WIKI

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