In a world that is not only fast but also unpredictable - relying on internal data is not enough anymore. With Forloop you can unlock and integrate external data, in no-code. Enabling you to adapt faster to the market and have an information advantage. Used today by data teams in Real Estate (to monitor the market, and price properties), E-commerce (to see trends, and support pricing strategy), VC (to source startups), Logistics (pricing of ship lanes) and more. The backbone of the technology is generative AI, to more automatically match your internal data with what market data would meet your objective.

Forloop.ai

Introduction Welcome to this module, Day 4 of 30-Day .NET Challenge: For Loops, where let's dive into the world of for statements. Explore how to write For Loop statements that iterate a set number of times. Learning Objectives Utilize the for statement to iterate through a set of code. Prerequisites for Developers Proficiency with the for each iteration statement. Familiarity with working with variables. Getting Started What is the for statement? The for statement allows you to iterate through a code block a fixed number of times, providing precise control over the iteration process. Basic For Loop Example To begin, create a static class file called “ForLoop.cs” within the console application. Insert the provided code snippet into this file. /// <summary>
/// Outputs
/// 0
/// 1
/// 2
/// 3
/// 4
/// 5
/// 6
/// 7
/// 8
/// 9
/// </summary>
public static void ForLoopExample()
{
    for (int i = 0; i < 10; i++)
    {
        Console.WriteLine(i);
    }
} Execute the code from the main method as follows #region Day 4 - For Loops

ForLoops.ForLoopExample();

#endregion Console Output // Console Output
0
1
2
3
4
5
6
7
8
9 Run For Loop in reverse. The goal is to iterate through a code block while counting down instead of counting up. Add another method into the same static class as shown below /// <summary>
/// Outputs
/// 10
/// 9
/// 8
/// 7
/// 6
/// 5
/// 4
/// 3
/// 2
/// 1
/// 0
/// </summary>
public static void BackwardForLoopExample()
{
    for (int i = 10; i >= 0; i--)
    {
        Console.WriteLine(i);
    }
} Execute the code from the main method as follows #region Day 4 - For Loops

ForLoops.BackwardForLoopExample();

#endregion Console Output // Console Output
10
9
8
7
6
5
4
3
2
1
0 Iterative Pattern With For The goal is to skip specific values in the iterator variable. Add another method into the same static class as shown below /// <summary>
/// Outputs
/// 3
/// 6
/// 0
/// 9
/// </summary>
public static void IterationForLoopExample()
{
    for (int i = 0; i < 10; i += 3)
    {
        Console.WriteLine(i);
    }
} Execute the code from the main method as follows #region Day 4 - For Loops

ForLoops.IterationForLoopExample();

#endregion Console Output // Console Output
0
3
6
9 Break Loop The goal is to exit the iteration statement prematurely based on some conditions. Add another method into the same static class as shown below /// <summary>
    /// Outputs
    /// 0
    /// 1
    /// 2
    /// 3
    /// 4
    /// 5
    /// 6
    /// 7
    /// </summary>
    public static void BreakForLoopExample()
    {
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine(i);
            if (i == 7) break;
        }
    } Execute the code from the main method as follows #region Day 4 - For Loops
    
    ForLoops.BreakForLoopExample();
    
    #endregion Console Output // Console Output
    0
    1
    2
    3
    4
    5
    6
    7 Complete Code on GitHub GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: If you’ve made it this far, please show your appreciation with a clap and follow the author! 👏️️ Follow us: | | | | | X LinkedIn Dev.to Hashnode Newsletter Tumblr Visit our other platforms: | | | | GitHub Instagram Tiktok Quora Daily.dev More content at C# Programming Also published . here

The 30-Day .NET Challenge Day 4: For Loops

I often see developers on wondering which of their code snippets is more performant. Usually, one of the snippets is similar to how things are done in Java while the other is a more Kotlin idiomatic way. Generally, the assumption tends to be that, by adding syntactic sugar, “the Kotlin way” is slower than the more verbose “Java way”. It is not always true. http://slack.kotlinlang.org/ Having a Java development background, whenever I am tasked with benchmarking performance of a code block/method, I automatically think of doing this: <a href="https://medium.com/media/aa8535696fc9e686269aae10563cf8b2/href">https://medium.com/media/aa8535696fc9e686269aae10563cf8b2/href</a> How many times have you had to write something similar in Java thinking that there must be a better way? The better way is finally here and, again, it comes from Kotlin. <a href="https://medium.com/media/f8a4ed4846bb5ea9a461e19f5aec46a0/href">https://medium.com/media/f8a4ed4846bb5ea9a461e19f5aec46a0/href</a> More intuitive and concise code, no math (albeit basic) all mean less chance of making an error when writing code. Note, (as well as ) is a standard library function. In Kotlin, when a function takes a lambda as the last argument, the latter may be supplied after the function call like so: measureTimeMillis measureNanoTime measureTimeMillis() {} And because there are no additional arguments passed into the function, the parentheses may be omitted altogether: measureTimeMillis {} Let’s see an example usage. We will compare performance between the basic for loop and the forEach function from Kotlin’s standard library when dealing with integers: <a href="https://medium.com/media/71e2b79d564b3423b61acff9a6b66050/href">https://medium.com/media/71e2b79d564b3423b61acff9a6b66050/href</a><a href="https://medium.com/media/25878a49c8832954c03d9630db6677f3/href">https://medium.com/media/25878a49c8832954c03d9630db6677f3/href</a> When I ran both, I got and printed for and respectively. So I set out to figure out what could possibly be the reason for the difference in performance. 3 milliseconds 15 milliseconds forLoopMillisElapsed forEachMillisEllapsed IntelliJ IDEA lets you easily decompile Kotlin code into Java using . Let’s decompile the two code blocks above and study the results: Tools > Kotlin > Show Kotlin Bytecode > Decompile The snippet with the for loop decompiled contains: <a href="https://medium.com/media/3cb3e3890536f4689262807322d4fe15/href">https://medium.com/media/3cb3e3890536f4689262807322d4fe15/href</a> The snippet with the forEach loop decompiled contains: <a href="https://medium.com/media/81d3b1e4dd1c466d78b5414c513b03ca/href">https://medium.com/media/81d3b1e4dd1c466d78b5414c513b03ca/href</a> Therefore, it’s logical to conclude that the forEach function in this particular case is slower than the regular for loop due to the overhead of the allocating an Iterator and Iterable objects when iterating over the array. Because it is so easy to get basic code performance measurements with Kotlin, I anticipate using measureTimeMillis in my code quite a bit going forward. That, along with studying the decompiled Kotlin byte code, is a great way to gain an insight into how Kotlin interacts with the JVM. Will the resulting code always be optimal? Not necessarily — there are always tradeoffs between code performance, clarity and conciseness. But that is a topic for another article.

Performance Tuning in Kotlin Made Easy

110 Stories To Learn About Time Management

175 Stories To Learn About Developer

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

In the last year, riveting news has been circulating on a 19-year old Nigerian founder who has taken the Tech-crypto world by the horns. His name is Njoku Emmanuel, CEO and CoFounder of Lazerpay, a crypto payment gateway startup with the main aim of facilitating crypto payments around the world for businesses and individuals. Lazerpay was launched in October 2021 alongside CoFounders Abdulfatai Sulaiman and Prosper Ubi, and has raised more than a million dollars for funding the company. In this episode of Founders Connect, Njoku shares his background with me. His undeniable passion for coding which stayed true despite the adversity of his parents and loved ones, the many places he has worked where he was given the opportunity to hone his skills, his love for technology and crypto and building, and his enthusiasm for the future of Lazerpay. I really enjoyed hearing him speak, and I hope you do too. Watch the video https://www.youtube.com/watch?v=Vsi51svEbnA Video transcripts 1:25 - Background 8:39 - How Njoku discovered the love for coding? 10:50 - His favourite Childhood memories? 12:30 - How he dropped out from Electrical Engineering and became a professional 16:08 - University Days, Meeting Ugochukwu Aronu of Xend, Working, Becoming A Web/Mobile Developer, Entrepreneurial Dreams 24:50 - ForLoop Enugu, Dealing Depression 28:52 - Learning about Blockchain 31:45 - Dropping out of school 33:00 - Lagos, Hackathon Incubation Programme, Ezvotes 37:05 - Days working at Kwivar 39:49 - Days working at Hydro Blockchain 42:50 - Days working (again) at Xend Finance with Ugochukwu 46:22 - Working at Maker DAO 52:50 - The making of Lazerpay 1:01:11 - Biggest milestones at Lazerpay 1:02:35 - How it feels being 19 and leading a company of 15 people 1:03:27 - Biggest Lessons learned from Lazerpay 1:06:21 - What should be looked forward to with Lazerpay

#FoundersConnect: Njoku Emmanuel, the 19-year-old CEO & Co-founder of Lazerpay

In this article, I will explain the Java 10 new feature: local variable type inference using reserved type name var. Java is changing rapidly and with the new release cycle of 6 months, we are getting new features to try with every release. In Java 10 a new feature Local-Variable Type Inference was added. It was basically aimed at reducing boilerplate code and improving the readability when declaring local variables with initializers. Programs must be written for people to read, and only incidentally for machines to execute~Harold Abelson Let's understand this with an example. Following code is written without using Local-Variable Type Inference. After refactoring as per Java 10 local variable type inference. In the above-refactored code, the compiler can infer the declared type itself by looking at the RHS declaration. These are just some of the examples to make you understand the feature and how we can use local variable type inference. Now let's understand where local variable type inference can be used and where it cannot be. Where it can be used Local variable initializers Indexes in the enhanced forloop Locals declared in a traditional forloop Resource variables of the try-with-resources statement Formal parameters of implicitly typed lambda expressions. (Support added in Java 11) The following code snippet shows some valid examples. Where it cannot be used Fields Method parameters Method return types Local variable declarations without any initialization Cannot use null for initialization I have tried to explain in the below code snippet what compiler error will come if it is used in a not supported way. What's the benefit? If you ask me personally I think developers should use it judiciously. It is understood that there is excitement whenever a feature comes in and you definitely want to give it try. But you have to understand that we as a developer read code more often then we write it. Since this is related to readability then some folks will like it and some will hate it. So if during a code review someone says that he/she is not able to get the declared type of var then it means that it is not very clear to others so maybe switching back to the old-fashioned way where we declare types explicitly is not that bad after all. Again in some situations declared type is quite obvious then you can skip the explicitly declared type and make use of the var. Conclusion In this article, we have covered what is Local-Variable Type Inference new Java 10 feature with some examples where it can be used and where it's not supported. You can further read these prepared by the OpenJDK team about Local-Variable Type Inference. FAQs Support me If you like what you just read then you can buy me a . coffee Further Reading You can continue your education by reading some of my previous . articles Also published at https://dev.to/yrashish/declare-var-not-war-1ofi

Introduction to Local Variable Type Inferences: Declare Var, Not War

I gave a talk about this topic a couple of months ago at forloop Summit Lagos, Nigeria. I decided to write a blog post out of it so here it goes. As developers, we are constantly trying to churn out work and we often find ourselves distracted from doing the actual work. In this article, I'll be sharing tips on how you can stay productive as a developer and also share tools to help automate this process. What is Productivity? Productivity is an act of getting quality work done without the need for adding extra effort. This is my definition of productivity and I am sure a lot of developers are already familiar with the term productivity. Daily in our lives, we all try to churn out meaningful work, tick that task off our to-do list and the cycle continues. One hard truth I'll like us to think about is how many developers around the world actually struggle with being unproductive daily due to different circumstances. Here's a fun fact. I think this is the case for most developers we don't work actively for straight 8 hours mind you if you do this then it's totally fine, this is just my point of view because I know in order to work efficiently you need breaks so please don't come for me :). Causes Of Low Productivity I'll be brief and butcher these points on why I think these are some causes of low productivity for developers. Our phone notifications, unread emails, and meetings are some of the biggest distractions that can cause us to be less productive during our working hours. I personally turned off notifications from all my devices when working yet there's still an urge to pick up my phone while working. Distractions: Burnout is real, when you spend your time working past your usual hours or when you are supposed to spend time away from work this will eventually lead to low productivity because all you eventually concerned about is work and the other part which is You is lacking. Low Work-Life Balance: An unhealthy company culture can also trigger low productivity in several ways. Working in a toxic environment significantly affect developers. People have to deal with some unpleasant scenario at the workplace and this tends to affect the quality of work they produce. Unhealthy Company Culture: Learning when to take a break is also key, A lot of developers are guilty of this act. If you overwork yourself you become stressed and that eventually leads to low work output and lack of productivity. Stress: Working at an organization that doesn't align with your goals or you are in a position where you keep doing the same task over and over without learning anything new or you don't see your self getting that promotion anytime soon then that can cause low productivity towards your work output. Lack of Growth Opportunities: Recommended Tips To Supercharge Your Productivity The best way to get rid of distractions is by restricting it entirely. What this means is you'll have to figure out ways to reduce the notifications and email you get. You can either mute notifications on your mobile devices or make sure you don't have it close to you when working. Use whatever works for you but the goal is to reduce distractions. Some tools that can help you are , , . Minimize Distractions: Stay Focused Self Control for Mac gofuckingwork As developers, this is one of the things I think we should be interested in because repeating a task can become daunting when we can automate it then why not. If you figure out you spend more than 2 minutes doing the same thing every day then you should find a way to automate that task. Tools for automating your process. , , . Automate Your Process: .dotfiles ohmyzsh cheatsheet Managing your time is another important tip you can leverage to stay productive. when you plan ahead efficiently it'll help boost your productivity. Some tools to leverage . Time Management: Tomato Timer It's important to work with the right tools, this way we don't spend a lot of time figuring out why the task we are trying to complete is not working as expected when we are using the wrong tool. Work With Right Tools: This is as necessary as every other tip I've shared. Take breaks when you need to and rest. If there's anything I've learned then it is I and my life comes first before any work because at the end if you're not healthy you won't be able to the work eventually. Take Breaks and Rest: This works for a couple of people, in fact, I've tried it and I saw the need to use this technique. Making sure to prioritize our work is one way to improve your productivity. You can either choose to do the hard and time-consuming task first and then do the easy ones last or vice versa whichever works for you but make sure you prioritize. Prioritize Your Work: I love note taking it's a habit for me and I've found that it's one way the works for me I take notes of what I want to accomplish for the day and at the end of the day I can visualize the amount of work I've been able to achieve. I must confess on some days this gives me chills and goosebumps other days I'm disappointed but still, I don't give up. Tools I use , , . Plan Ahead With Note Taking: Notion Numi Taskade I can't emphasize this enough make sure you break up your tasks into smaller chunks that way you're able to visualize them in bits size and it doesn't become overwhelming for you to achieve. Break Tasks Into Chunks: Lastly, use your calendar. Schedule activities for the week so that you don't skip or forget things you're supposed to do. Personally, I use Schedule Your Time: Google Calendar How Do You Define Success? After going through these steps and applying these tips, how do you know when you've succeeded. You know you've succeeded when you can now effectively manage your time and stick to it and there's a noticeable improvement in the work you churn out. Improved Time Management: You are now very focused and stable because you have dedicated time to rest and take breaks so you feel refreshed when working. Gain Focus And Stability: The amount of valuable work you achieve now leads to possible promotion including better opportunities. Career Advancement: You now have proper work-life balance, no signs of burnout and you can take time outside work to go on a vacation or spend time with family. Work-Life Balance: I hope you found these few tips helpful and you can start using them in your daily workflow to improve your productivity as a developer. You can find the talk slides here

Forloop.ai

forloop.ai

11-50 employees

Since 2021

COMPANY RANKING

FORLOOP.AI

EVERGREEN INDEX #5144

Forloop.ai WIKI

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

Forloop.ai

forloop.ai

11-50 employees

Since 2021

COMPANY RANKING

FORLOOP.AI

EVERGREEN INDEX #5144

RELATED COMPANIESRANK

STORIES ABOUT FORLOOP.AI

Forloop.ai WIKI

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