At the most recent staging of the JIFS/JBA AML/CFT Conference, Symptai Consulting Limited, a leading expert in cybersecurity, digital transformation, and anti-money laundering (AML) in the Caribbean, highlights the critical role artificial intelligen

Symptai advances cybersecurity and AI in anti-money laundering efforts | Loop Jamaica

After years of staffing, coordination, pushback, revamping and rewriting, the Department of Defense has finalized rules for the Cybersecurity Maturity Model Certification (CMMC) program.

OODA Loop - Department of Defense Implements Cybersecurity Maturity Model Certification Rule

Loop

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

If you’ve been writing Go code for a while, you’ve probably come across range loops. They’re elegant, concise, and incredibly handy for iterating over slices, maps, and channels. But did you know that their behavior can sometimes be counterintuitive, leading to subtle bugs in your code? In this article, I’ll break down the mechanics of range loops, explain why these quirks occur, and share actionable tips to avoid common pitfalls. By the end, you’ll have a deeper understanding of Go and be better equipped to write reliable, bug-free code. 🚀 What Makes Range Loops Tricky? At first glance, range loops in Go appear straightforward. Here’s an example you’ve likely seen: codenumbers := []int{1, 2, 3, 4, 5}  
for index, value := range numbers {  
    fmt.Printf("Index: %d, Value: %d\n", index, value)  
} This prints the index and value for each element in the slice. Simple, right? But here’s where things get interesting (and potentially frustrating). The Underlying Mechanics of Range When you use range, Go creates a copy of the value you’re iterating over. For slices, this means you’re not directly accessing the elements but working with their copies. This subtle detail can lead to unexpected behavior. Take this example: codewords := []string{"Go", "is", "awesome"}  
wordPointers := []*string{}  

for _, word := range words {  
    wordPointers = append(wordPointers, &word)  
}  

for _, pointer := range wordPointers {  
    fmt.Println(*pointer)  
} You might expect this to print: Go  
is  
awesome But instead, you’ll see: awesome  
awesome  
awesome Why? Because word is a single variable reused in every iteration. The loop appends the same variable’s address each time, and by the end of the loop, word holds the value of the last element. Avoiding Common Pitfalls Here are some tips to keep your range loops bug-free: Understand Copying Behavior:If you’re modifying elements, remember thatrange loops work with copies for slices and arrays. Use index-based access if you need to modify the original elements.
for i := range numbers {  
    numbers[i] *= 2  
}  




Be Cautious with Pointers:If you need to capture references to elements, use the index instead of the loop variable.
for i := range words {  
    wordPointers = append(wordPointers, &words[i])  
}  




Debug Complex Loops:Usefmt.Printf to inspect variables and their memory addresses. This helps identify if you’re unintentionally working with shared references. Why This Matters Understanding these quirks isn’t just about avoiding bugs—it’s about mastering Go. As you tackle more complex projects, these small details can have significant impacts on performance, correctness, and maintainability. This article is part of a series I’m writing to explore common mistakes in Go programming. The first topic, range loops, is something many developers encounter but don’t fully understand until they’ve run into a bug. Final Thoughts Range loops are one of Go’s most powerful tools, but like any tool, they come with nuances. By understanding how they evaluate and iterate over elements, you can write cleaner, more reliable code. If you’ve ever been bitten by a range loop bug—or have tips of your own—I’d love to hear from you! Let’s share knowledge and grow as a community. 🔗 Read the full article on my LinkedIn For more insights like this, follow my journey in exploring the intricacies of Go programming. 🚀 If you’ve been writing Go code for a while, you’ve probably come across range loops. They’re elegant, concise, and incredibly handy for iterating over slices, maps, and channels. But did you know that their behavior can sometimes be counterintuitive, leading to subtle bugs in your code? range In this article, I’ll break down the mechanics of range loops, explain why these quirks occur, and share actionable tips to avoid common pitfalls. By the end, you’ll have a deeper understanding of Go and be better equipped to write reliable, bug-free code. 🚀 range What Makes Range Loops Tricky? What Makes Range At first glance, range loops in Go appear straightforward. Here’s an example you’ve likely seen: range codenumbers := []int{1, 2, 3, 4, 5}  
for index, value := range numbers {  
    fmt.Printf("Index: %d, Value: %d\n", index, value)  
} codenumbers := []int{1, 2, 3, 4, 5}  
for index, value := range numbers {  
    fmt.Printf("Index: %d, Value: %d\n", index, value)  
} This prints the index and value for each element in the slice. Simple, right? But here’s where things get interesting (and potentially frustrating). The Underlying Mechanics of Range The Underlying Mechanics of Range When you use range , Go creates a copy of the value you’re iterating over. For slices, this means you’re not directly accessing the elements but working with their copies. This subtle detail can lead to unexpected behavior. range Take this example: codewords := []string{"Go", "is", "awesome"}  
wordPointers := []*string{}  

for _, word := range words {  
    wordPointers = append(wordPointers, &word)  
}  

for _, pointer := range wordPointers {  
    fmt.Println(*pointer)  
} codewords := []string{"Go", "is", "awesome"}  
wordPointers := []*string{}  

for _, word := range words {  
    wordPointers = append(wordPointers, &word)  
}  

for _, pointer := range wordPointers {  
    fmt.Println(*pointer)  
} You might expect this to print: Go  
is  
awesome Go  
is  
awesome But instead, you’ll see: awesome  
awesome  
awesome awesome  
awesome  
awesome Why? Because word is a single variable reused in every iteration. The loop appends the same variable’s address each time, and by the end of the loop, word holds the value of the last element. word word Avoiding Common Pitfalls Avoiding Common Pitfalls Here are some tips to keep your range loops bug-free: range Understand Copying Behavior:If you’re modifying elements, remember thatrange loops work with copies for slices and arrays. Use index-based access if you need to modify the original elements.
for i := range numbers {  
    numbers[i] *= 2  
} Be Cautious with Pointers:If you need to capture references to elements, use the index instead of the loop variable.
for i := range words {  
    wordPointers = append(wordPointers, &words[i])  
} Debug Complex Loops:Usefmt.Printf to inspect variables and their memory addresses. This helps identify if you’re unintentionally working with shared references. Understand Copying Behavior:If you’re modifying elements, remember thatrange loops work with copies for slices and arrays. Use index-based access if you need to modify the original elements. for i := range numbers {  
    numbers[i] *= 2  
} Understand Copying Behavior : If you’re modifying elements, remember that range loops work with copies for slices and arrays. Use index-based access if you need to modify the original elements. Understand Copying Behavior range for i := range numbers {  
    numbers[i] *= 2  
} for i := range numbers {  
    numbers[i] *= 2  
} Be Cautious with Pointers:If you need to capture references to elements, use the index instead of the loop variable. for i := range words {  
    wordPointers = append(wordPointers, &words[i])  
} Be Cautious with Pointers : If you need to capture references to elements, use the index instead of the loop variable. Be Cautious with Pointers for i := range words {  
    wordPointers = append(wordPointers, &words[i])  
} for i := range words {  
    wordPointers = append(wordPointers, &words[i])  
} Debug Complex Loops:Usefmt.Printf to inspect variables and their memory addresses. This helps identify if you’re unintentionally working with shared references. Debug Complex Loops : Use fmt.Printf to inspect variables and their memory addresses. This helps identify if you’re unintentionally working with shared references. Debug Complex Loops fmt.Printf Why This Matters Why This Matters Understanding these quirks isn’t just about avoiding bugs—it’s about mastering Go. As you tackle more complex projects, these small details can have significant impacts on performance, correctness, and maintainability. This article is part of a series I’m writing to explore common mistakes in Go programming. The first topic, range loops, is something many developers encounter but don’t fully understand until they’ve run into a bug. range Final Thoughts Final Thoughts Range loops are one of Go’s most powerful tools, but like any tool, they come with nuances. By understanding how they evaluate and iterate over elements, you can write cleaner, more reliable code. Range If you’ve ever been bitten by a range loop bug—or have tips of your own—I’d love to hear from you! Let’s share knowledge and grow as a community. range 🔗 Read the full article on my LinkedIn Read the full article on my LinkedIn For more insights like this, follow my journey in exploring the intricacies of Go programming. 🚀

Unlock the Secrets of Range Loops: How Element Evaluation Affects Your Go Code

Data science and user experience design have recently become critical to the success of companies' sophisticated internal digital tools for analyzing, processing information, and predicting what-if scenarios. Used by internal teams and operations staff, these tools aim to optimize processes, predict outcomes, and inform decision-making in increasingly complex systems. For those working in data science, a common approach is to view humans as “human-in-the-loop,” meaning users provide inputs to a system or validate outputs, but their role remains secondary to technology and algorithms. It is worth considering that the complexity and nuanced requirements of modeling tools have begun to require a shift to a more human-centered approach to make the tools accessible to a wider audience. This article examines human-centered design and the need for such a focus for those working on data science projects and suggests strategies to facilitate this transition. Determining the Difference To address human-related issues (emotional state, learning, outcome), the concept of “human-in-the-loop” (HITL) was introduced, which involves incorporating human knowledge into the modeling process. The HITL approach is often a common way of thinking among data science teams, where humans are seen as secondary players who help the machine function better or validate the results generated by algorithms. This interdisciplinary approach crosses computer science, cognitive science, and psychology and consists of three components: data preprocessing, data modeling, and process modification to improve performance. However, it is important to consider that the results and performance of ML models can be unpredictable, so it remains unclear which aspect of human-machine interaction yields the best learning results. People are thus viewed as add-ons to the system—sources of labeled data, corrections, or ideas that help fine-tune the models—without taking into account their broader needs, motivations, or limitations. Human involvement depends on the type of solution being implemented: strategic, tactical, or operational. In operational and tactical systems, the human role is usually minimal. In contrast, in strategic solutions, the human role is critical because these decisions require context, explainability, and domain expertise. They often rely on human interpretation to validate assumptions, assess risks, and align outcomes with broader goals. Human-centered design, on the other hand, places the user at the center of the design and development process by aligning technology with human needs, behaviors, motivation, and goals. Understanding the "why" behind user behaviors is a key component of human-centered design, which integrates user context and requirements thoroughly into all phases of product development. For data scientists, embracing human-centered design is more than just incorporating human input into systems; it also entails actively reshaping systems to meet the actual users’ needs and developing tools that empower rather than burden them. Why Human-Centered Design Matters In complex, high-stakes environments, inconsistent forecasts, confusing workflows, or overly complex interfaces can lead to poor decision-making, frustration, and operational inefficiencies. That’s why a human-centered approach is invaluable in such settings, enabling users to receive answers tailored to their needs. Often, users view data science solutions as “black boxes,” making it difficult to trust them or understand the results they produce. Developing tools and solutions that explain the relationships between inputs and outputs and the behavior of models can improve trust and usability, empowering users to confidently make informed decisions. This need for explainability and transparency is directly related to the need for human-centered design and more understandable solutions. When tools are designed with end-users in mind, they are more likely to be adopted and used effectively by users. When data scientists understand the nuances of user tasks, they can create models and interfaces that match users’ real workflows and contexts, rather than idealized or abstract ones. This increases trust in the tool’s output and minimizes the learning curve for users. Moreover, the accuracy and applicability of machine learning models can be highly dependent on the user context. These subtleties are better captured by a human-centered approach, which ultimately produces more accurate and meaningful predictions for users. By providing users with the tools they need to make informed decisions, human-centered design empowers users. Instead of relying on the user to validate a machine’s predictions, tools can allow users to make decisions alongside the machine, fostering collaboration rather than a directive relationship. Practical Steps to Move Toward Human-Centered Design While the benefits of human-centered design may be clear and obvious, shifting from a “human in the loop” requires both structural changes and cultural and team support. Here are some actionable steps teams can take to embrace human-centered design. 1. User Research First Researching users and their context is fundamental to human-centered design. Thus, interviews, ethnographic studies, observations of users’ workflows, and identification of pain points, motivations, and goals help to better understand and study users. Such research produces qualitative insights that can be complemented by quantitative data, providing a deeper understanding of users' context. Additionally, creating user journey maps that detail the workflows and touchpoints users have with various tools and other organizational functions allows for a more accurate assessment of what users are experiencing. This visual tool can help highlight opportunities where these tools can add more value or streamline user processes. 2. Prototype With a Purpose To make efficient use of a team's time by experimenting with different models, assumptions, and data visualizations while focusing not only on achieving technical goals but also on creating features that are clear, relevant, and useful to the user, rapid prototyping can help. It’s a fundamental practice of human-centered design that brings ideas to life and allows users to test the prototype early, for example in Figma, without spending time on development. This ensures that user feedback is obtained before a huge amount of time is spent on product development and helps to quickly get to the point where the user's problem is solved by matching the real needs and defining what tasks the user needs to perform to achieve it. 3. Design for Trust and Transparency A critical component of human-centered design is building trust and transparency so that when users receive forecasts or recommendations, they understand the validity of those results and can make business decisions and act on them with confidence. Trust in data tools can be achieved by helping users understand why the system suggests a certain outcome or path and by visualizing results that are understandable to the user and consistent with their mental model. 4. Development of a Collaborative and Interdisciplinary Team Culture Creating successful human-centered data tools requires collaboration across disciplines. Having a shared team vision based on the human-centered design will help bridge gaps in expertise and perspectives, ensuring that the final digital solution meets all team goals, prioritising user satisfaction, usability, and utility. Additionally, building empathy through shared UX activities helps develop a more empathetic understanding of the end user. 5. Measuring Success With User-Centric Metrics Implementing human-centred design means going beyond technical success metrics and focusing on including metrics that reflect user satisfaction and performance: a) regular feedback from users on their satisfaction with the tool and specific features; b) task success rates and time to complete them; c) feedback loops such as surveys or regular feedback sessions that help identify and resolve issues in real time, rather than waiting for problems to escalate. Conclusion Moving from “human-in-the-loop” to human-centred design is a mindset shift that emphasises designing for users rather than simply using users to validate machine output. In companies where decisions can have a high impact and significant risk, human-centred design helps better align tools with users' real-world needs and context. For data scientists, this mental shift paves the way for building digital tools that are not only functionally efficient but also truly empower users and enable them to engage a broader audience. When data tools are built with a human-centric mindset, they become tools that help users make better, faster, and more confident decisions, ultimately improving both the user experience and operational outcomes. Data science and user experience design have recently become critical to the success of companies' sophisticated internal digital tools for analyzing, processing information, and predicting what-if scenarios. Used by internal teams and operations staff, these tools aim to optimize processes, predict outcomes, and inform decision-making in increasingly complex systems. For those working in data science, a common approach is to view humans as “human-in-the-loop,” meaning users provide inputs to a system or validate outputs, but their role remains secondary to technology and algorithms. It is worth considering that the complexity and nuanced requirements of modeling tools have begun to require a shift to a more human-centered approach to make the tools accessible to a wider audience. This article examines human-centered design and the need for such a focus for those working on data science projects and suggests strategies to facilitate this transition. Determining the Difference To address human-related issues (emotional state, learning, outcome), the concept of “human-in-the-loop” (HITL) was introduced, which involves incorporating human knowledge into the modeling process. The HITL approach is often a common way of thinking among data science teams, where humans are seen as secondary players who help the machine function better or validate the results generated by algorithms. This interdisciplinary approach crosses computer science, cognitive science, and psychology and consists of three components: data preprocessing, data modeling, and process modification to improve performance. However, it is important to consider that the results and performance of ML models can be unpredictable, so it remains unclear which aspect of human-machine interaction yields the best learning results. People are thus viewed as add-ons to the system—sources of labeled data, corrections, or ideas that help fine-tune the models—without taking into account their broader needs, motivations, or limitations. Human involvement depends on the type of solution being implemented: strategic, tactical, or operational. In operational and tactical systems, the human role is usually minimal. In contrast, in strategic solutions, the human role is critical because these decisions require context, explainability, and domain expertise. They often rely on human interpretation to validate assumptions, assess risks, and align outcomes with broader goals. Human-centered design, on the other hand, places the user at the center of the design and development process by aligning technology with human needs, behaviors, motivation, and goals. Understanding the "why" behind user behaviors is a key component of human-centered design, which integrates user context and requirements thoroughly into all phases of product development. For data scientists, embracing human-centered design is more than just incorporating human input into systems; it also entails actively reshaping systems to meet the actual users’ needs and developing tools that empower rather than burden them. Why Human-Centered Design Matters In complex, high-stakes environments, inconsistent forecasts, confusing workflows, or overly complex interfaces can lead to poor decision-making, frustration, and operational inefficiencies. That’s why a human-centered approach is invaluable in such settings, enabling users to receive answers tailored to their needs. Often, users view data science solutions as “black boxes,” making it difficult to trust them or understand the results they produce. Developing tools and solutions that explain the relationships between inputs and outputs and the behavior of models can improve trust and usability, empowering users to confidently make informed decisions. This need for explainability and transparency is directly related to the need for human-centered design and more understandable solutions. When tools are designed with end-users in mind, they are more likely to be adopted and used effectively by users. When data scientists understand the nuances of user tasks, they can create models and interfaces that match users’ real workflows and contexts, rather than idealized or abstract ones. This increases trust in the tool’s output and minimizes the learning curve for users. Moreover, the accuracy and applicability of machine learning models can be highly dependent on the user context. These subtleties are better captured by a human-centered approach, which ultimately produces more accurate and meaningful predictions for users. By providing users with the tools they need to make informed decisions, human-centered design empowers users. Instead of relying on the user to validate a machine’s predictions, tools can allow users to make decisions alongside the machine, fostering collaboration rather than a directive relationship. Practical Steps to Move Toward Human-Centered Design While the benefits of human-centered design may be clear and obvious, shifting from a “human in the loop” requires both structural changes and cultural and team support. Here are some actionable steps teams can take to embrace human-centered design. 1. User Research First Researching users and their context is fundamental to human-centered design. Thus, interviews, ethnographic studies, observations of users’ workflows, and identification of pain points, motivations, and goals help to better understand and study users. Such research produces qualitative insights that can be complemented by quantitative data, providing a deeper understanding of users' context. Additionally, creating user journey maps that detail the workflows and touchpoints users have with various tools and other organizational functions allows for a more accurate assessment of what users are experiencing. This visual tool can help highlight opportunities where these tools can add more value or streamline user processes. 2. Prototype With a Purpose To make efficient use of a team's time by experimenting with different models, assumptions, and data visualizations while focusing not only on achieving technical goals but also on creating features that are clear, relevant, and useful to the user, rapid prototyping can help. It’s a fundamental practice of human-centered design that brings ideas to life and allows users to test the prototype early, for example in Figma, without spending time on development. This ensures that user feedback is obtained before a huge amount of time is spent on product development and helps to quickly get to the point where the user's problem is solved by matching the real needs and defining what tasks the user needs to perform to achieve it. 3. Design for Trust and Transparency A critical component of human-centered design is building trust and transparency so that when users receive forecasts or recommendations, they understand the validity of those results and can make business decisions and act on them with confidence. Trust in data tools can be achieved by helping users understand why the system suggests a certain outcome or path and by visualizing results that are understandable to the user and consistent with their mental model. 4. Development of a Collaborative and Interdisciplinary Team Culture Creating successful human-centered data tools requires collaboration across disciplines. Having a shared team vision based on the human-centered design will help bridge gaps in expertise and perspectives, ensuring that the final digital solution meets all team goals, prioritising user satisfaction, usability, and utility. Additionally, building empathy through shared UX activities helps develop a more empathetic understanding of the end user. 5. Measuring Success With User-Centric Metrics Implementing human-centred design means going beyond technical success metrics and focusing on including metrics that reflect user satisfaction and performance: a) regular feedback from users on their satisfaction with the tool and specific features; b) task success rates and time to complete them; c) feedback loops such as surveys or regular feedback sessions that help identify and resolve issues in real time, rather than waiting for problems to escalate. Conclusion Moving from “human-in-the-loop” to human-centred design is a mindset shift that emphasises designing for users rather than simply using users to validate machine output. In companies where decisions can have a high impact and significant risk, human-centred design helps better align tools with users' real-world needs and context. For data scientists, this mental shift paves the way for building digital tools that are not only functionally efficient but also truly empower users and enable them to engage a broader audience. When data tools are built with a human-centric mindset, they become tools that help users make better, faster, and more confident decisions, ultimately improving both the user experience and operational outcomes.

Design and Data Science: From a Human-in-the-Loop Approach to Human-Centered Design

Over-optimized loops hurt the eyes TL;DR: Don't optimize loops without a clear need and concrete real-world evidence Problems Premature Optimization
Reduced readability
Increased complexity
Difficult to maintain
Slower debugging Solutions Keep it simple
Prioritize clarity
Avoid premature tweaks
Refactor when needed Context You might think optimizing every loop will improve performance, but this approach backfires when you sacrifice clarity for unproven gains. Writing complex code to avoid hypothetical slowdowns often makes it hard for others (and your future self) to understand or debug your code. It would be best if you prioritized readability. Keep loops simple and only optimize when you know a bottleneck exists in real usage scenarios. Sample Code Wrong # Over-optimized and less readable
result = [item.process() for item in items if item.is_valid()] Right # Clearer and easier to understand
result = []
for item in items:
    if item.is_valid():
        result.append(item.process()) Detection [x]Semi-Automatic Look for list comprehensions or complex loop structures that optimize performance without real performance benchmark evidence. Exceptions Concrete evidence on mission-critical algorithms Tags Premature Optimization Level [x]Intermediate AI Generation AI tools often prioritize functional correctness so that they might produce clean, simple loops. if you prompt AI for performance at all costs, it could create over-optimized code even for straightforward tasks. AI Detection With proper instructions to stress readability and maintainability, AI can detect and fix this smell by simplifying loops and choosing clarity over premature optimization. Try Them! Remember: AI Assistants make lots of mistakes Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



Gemini

Gemini Conclusion Don’t sacrifice readability by optimizing too early. You can optimize later if a loop becomes a proven bottleneck. Until then, clear and simple code will save time, reduce bugs, and make it more maintainable. Related Reading https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iv-7sc3w8n https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-ii-o96s3wl4 Disclaimer: Code Smells are my opinion. Credit(s): Photo by Tine Ivanič on Unsplash More computing sins are committed in the name of efficiency without necessarily achieving it than for any other single reason. W. A. Wulf https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series: How to Find the Stinky Parts of your Code Over-optimized loops hurt the eyes Over-optimized loops hurt the eyes TL;DR: Don't optimize loops without a clear need and concrete real-world evidence TL;DR: Don't optimize loops without a clear need and concrete real-world evidence Problems Premature Optimization Reduced readability Increased complexity Difficult to maintain Slower debugging Premature Optimization Premature Optimization Reduced readability Increased complexity Difficult to maintain Slower debugging Solutions Keep it simple Prioritize clarity Avoid premature tweaks Refactor when needed Keep it simple Prioritize clarity Avoid premature tweaks Refactor when needed Context You might think optimizing every loop will improve performance, but this approach backfires when you sacrifice clarity for unproven gains. Writing complex code to avoid hypothetical slowdowns often makes it hard for others (and your future self) to understand or debug your code. It would be best if you prioritized readability. Keep loops simple and only optimize when you know a bottleneck exists in real usage scenarios. hypothetical real usage Sample Code Wrong # Over-optimized and less readable
result = [item.process() for item in items if item.is_valid()] # Over-optimized and less readable
result = [item.process() for item in items if item.is_valid()] Right # Clearer and easier to understand
result = []
for item in items:
    if item.is_valid():
        result.append(item.process()) # Clearer and easier to understand
result = []
for item in items:
    if item.is_valid():
        result.append(item.process()) Detection [x]Semi-Automatic [x] Semi-Automatic [x] Look for list comprehensions or complex loop structures that optimize performance without real performance benchmark evidence. Exceptions Concrete evidence on mission-critical algorithms Concrete evidence on mission-critical algorithms Tags Premature Optimization Premature Optimization Level [x]Intermediate [x] Intermediate [x] AI Generation AI tools often prioritize functional correctness so that they might produce clean, simple loops. if you prompt AI for performance at all costs, it could create over-optimized code even for straightforward tasks. AI Detection With proper instructions to stress readability and maintainability, AI can detect and fix this smell by simplifying loops and choosing clarity over premature optimization. Try Them! Try Them! Remember: AI Assistants make lots of mistakes Remember: AI Assistants make lots of mistakes Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



Gemini

Gemini Without Proper Instructions

With Specific Instructions ChatGPT

ChatGPT Claude

Claude Perplexity

Perplexity Copilot

Copilot Gemini

Gemini Without Proper Instructions With Specific Instructions Without Proper Instructions Without Proper Instructions With Specific Instructions With Specific Instructions ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT Claude Claude Claude Claude Claude Claude Claude Claude Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Copilot Copilot Copilot Copilot Copilot Copilot Copilot Copilot Gemini Gemini Gemini Gemini Gemini Gemini Gemini Gemini Conclusion Don’t sacrifice readability by optimizing too early. You can optimize later if a loop becomes a proven bottleneck. Until then, clear and simple code will save time, reduce bugs, and make it more maintainable. Related Reading https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iv-7sc3w8n https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iv-7sc3w8n https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-ii-o96s3wl4 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-ii-o96s3wl4 Disclaimer: Code Smells are my opinion. Disclaimer: Code Smells are my opinion . opinion Credit(s): Photo by Tine Ivanič on Unsplash Credit(s): Photo by Tine Ivanič on Unsplash Tine Ivanič Unsplash More computing sins are committed in the name of efficiency without necessarily achieving it than for any other single reason. More computing sins are committed in the name of efficiency without necessarily achieving it than for any other single reason. W. A. Wulf W. A. Wulf https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series: How to Find the Stinky Parts of your Code 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 279 - Loop Premature Optimization

One key concept central to ensuring that AI remains a tool that benefits humanity rather than harms it is the notion of "Human in the Loop" (HITL). But what exactly is HITL, and why is it so vital in today’s AI landscape? What is "Human in the Loop"? Human in the Loop (HITL) refers to a system design in which humans are actively involved in the decision-making process of an AI system. Unlike fully automated AI systems that operate without any human intervention, HITL systems incorporate human judgment at critical stages—especially when decisions involve high stakes or ethical considerations. This model relies on a combination of machine efficiency and human intuition, ensuring that the final output is aligned with human values and societal norms. The Importance of a "Kill Switch" One of the most crucial aspects of HITL systems is the integration of a "kill switch" or an emergency stop mechanism. This is a literal or metaphorical button that allows human operators to override AI decisions or shut down the system entirely if it starts behaving in unintended or harmful ways. A kill switch is not just a precaution; it is a safeguard that recognizes the inherent unpredictability of AI systems, especially as they grow more complex and autonomous. AI, by design, can learn and adapt in ways that even its creators might not fully anticipate. Without the ability for a human to intervene—whether to halt a runaway algorithm or correct a decision that could have disastrous consequences—we risk losing control over the very technologies we created. This is particularly critical in sectors like healthcare, finance, and law enforcement, where AI-driven decisions can significantly impact human lives. Why HITL is Essential for Ethical and Safe AI As AI continues to infiltrate our daily lives, from facial recognition systems to predictive policing algorithms, ethical concerns have risen to the forefront. HITL is essential to ensuring that AI systems remain fair, transparent, and aligned with human rights. For instance, without human oversight, AI algorithms trained on biased data can perpetuate or even exacerbate discrimination. By keeping humans in the loop, we introduce a level of accountability that purely automated systems lack. Moreover, HITL offers a vital counterbalance to the "black box" nature of many AI systems. These systems often provide outputs without clear explanations of how they reached their conclusions. Human oversight allows us to question, validate, and adjust these decisions, reducing the risks associated with opaque or unexplainable outcomes. The Unseen Influence of AI on Our Lives Even without us fully realizing it, AI is already shaping our behaviors and choices. Social media algorithms decide which content we see, influencing our opinions and emotions. Recommender systems on platforms like YouTube, Netflix, and Amazon subtly guide our consumption habits, reinforcing our preferences while sometimes trapping us in echo chambers. The concerning part is that many of these AI-driven systems operate without meaningful human intervention or oversight. They are optimized for engagement and profit, often at the expense of societal well-being. These systems continuously learn from our interactions, amplifying biases, spreading misinformation, and fueling polarization—all without our conscious input or control. This highlights the urgent need for HITL in AI governance. By incorporating human judgment, we can steer these systems away from harmful outcomes, ensuring that they work for us rather than against us. Conclusion: A Call for Responsible AI Design Human in the Loop is more than a technical framework; it’s a philosophical stance that recognizes the limits of automation. As AI becomes more embedded in the fabric of our society, we must resist the temptation to hand over full control to machines. We must maintain a human presence, not just as operators but as moral arbiters, constantly assessing whether these systems are truly serving the common good. A future where AI operates unchecked and devoid of human oversight is not a distant dystopia; it’s a possibility that’s already creeping into our reality. By embracing HITL and embedding robust kill switches into AI systems, we can ensure that technology remains a tool that empowers humanity rather than endangering it. In an age where machines can learn and adapt faster than ever before, keeping humans in the loop is not just advisable—it’s essential. About Me: 25+ year IT veteran combining data, AI, risk management, strategy, and education. 4x hackathon winner and social impact from data advocate. Currently working to jumpstart the AI workforce in the Philippines. Learn more about me here: https://docligot.com One key concept central to ensuring that AI remains a tool that benefits humanity rather than harms it is the notion of "Human in the Loop" (HITL). But what exactly is HITL, and why is it so vital in today’s AI landscape? What is "Human in the Loop"? Human in the Loop (HITL) refers to a system design in which humans are actively involved in the decision-making process of an AI system. Unlike fully automated AI systems that operate without any human intervention, HITL systems incorporate human judgment at critical stages—especially when decisions involve high stakes or ethical considerations. This model relies on a combination of machine efficiency and human intuition, ensuring that the final output is aligned with human values and societal norms. system design in which humans are actively involved The Importance of a "Kill Switch" One of the most crucial aspects of HITL systems is the integration of a "kill switch" or an emergency stop mechanism . This is a literal or metaphorical button that allows human operators to override AI decisions or shut down the system entirely if it starts behaving in unintended or harmful ways. A kill switch is not just a precaution; it is a safeguard that recognizes the inherent unpredictability of AI systems, especially as they grow more complex and autonomous. integration of a "kill switch" or an emergency stop mechanism AI, by design, can learn and adapt in ways that even its creators might not fully anticipate. Without the ability for a human to intervene—whether to halt a runaway algorithm or correct a decision that could have disastrous consequences—we risk losing control over the very technologies we created. This is particularly critical in sectors like healthcare, finance, and law enforcement, where AI-driven decisions can significantly impact human lives. Why HITL is Essential for Ethical and Safe AI As AI continues to infiltrate our daily lives, from facial recognition systems to predictive policing algorithms, ethical concerns have risen to the forefront. HITL is essential to ensuring that AI systems remain fair, transparent, and aligned with human rights. For instance, without human oversight, AI algorithms trained on biased data can perpetuate or even exacerbate discrimination. By keeping humans in the loop, we introduce a level of accountability that purely automated systems lack. Moreover, HITL offers a vital counterbalance to the "black box" nature of many AI systems . These systems often provide outputs without clear explanations of how they reached their conclusions. Human oversight allows us to question, validate, and adjust these decisions, reducing the risks associated with opaque or unexplainable outcomes. "black box" nature of many AI systems The Unseen Influence of AI on Our Lives Even without us fully realizing it, AI is already shaping our behaviors and choices. Social media algorithms decide which content we see, influencing our opinions and emotions. Recommender systems on platforms like YouTube, Netflix, and Amazon subtly guide our consumption habits, reinforcing our preferences while sometimes trapping us in echo chambers. The concerning part is that many of these AI-driven systems operate without meaningful human intervention or oversight. They are optimized for engagement and profit, often at the expense of societal well-being. These systems continuously learn from our interactions, amplifying biases, spreading misinformation, and fueling polarization—all without our conscious input or control. This highlights the urgent need for HITL in AI governance. By incorporating human judgment, we can steer these systems away from harmful outcomes, ensuring that they work for us rather than against us. Conclusion: A Call for Responsible AI Design Human in the Loop is more than a technical framework; it’s a philosophical stance that recognizes the limits of automation. As AI becomes more embedded in the fabric of our society, we must resist the temptation to hand over full control to machines. We must maintain a human presence, not just as operators but as moral arbiters, constantly assessing whether these systems are truly serving the common good. A future where AI operates unchecked and devoid of human oversight is not a distant dystopia; it’s a possibility that’s already creeping into our reality. By embracing HITL and embedding robust kill switches into AI systems, we can ensure that technology remains a tool that empowers humanity rather than endangering it. In an age where machines can learn and adapt faster than ever before, keeping humans in the loop is not just advisable—it’s essential. About Me: 25+ year IT veteran combining data, AI, risk management, strategy, and education. 4x hackathon winner and social impact from data advocate. Currently working to jumpstart the AI workforce in the Philippines. Learn more about me here: https://docligot.com https://docligot.com

Stories, News & Mentions about LOOP

Loop’s Stories on HackerNoon

Loop's News & Mentions