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

forloopai

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

Tips To Supercharge Your Productivity As A Developer

A few weeks ago I wrote an article about calculating the probability of certain outcomes in BlackJack using Python. If you want to read that article, feel free. . https://hackernoon.com/gambling-probability-python-dfd3e301b1ad The idea was that you could set up a scenario in blackjack by creating a simulated game. Then simulate the outcome of that game a million times, and figure out what the probability is of certain outcomes. It got me thinking though, how much more useful something like that would be if I created an actual game that would calculate those probabilities in real time. So, I set out to do that. In this post, I’ll talk about some ideas in how to go about creating such an application, if you’ve ever been interested in doing so, as well as some of the logic behind how I made mine work. If you want to see the final product of my application before reading any further, here’s what I have so far: . https://safe-springs-65895.herokuapp.com/ The API To get started, I found this fantastic API for playing cards: . https://deckofcardsapi.com/ It’s a great tool for getting started, and allows you to make several types of API calls depending on your needs. For example, you can either get a brand new deck of cards, or shuffle an existing deck by using a deck ID#. Either way, after getting the deck of cards, you can draw a card from the deck. In theory, it would make sense to make a request that would draw one or two cards each time a player in the game clicks a button to draw a card. For example, the url for the deck shuffle looks like this: https://deckofcardsapi.com/api/deck/new/shuffle/?deck_count=1 Then, if you wanted to draw a card, you would use: https://deckofcardsapi.com/api/deck/<<deck_id>>/draw/?count=2 However, I found that for my purposes, I wanted to draw all 52 cards at once, and use the remaining values from the deck to calculate the probabilities I would use later. So when a player starts a new game, I would actually do this: https://deckofcardsapi.com/api/deck/<<deck_id>>/draw/?count=52 And then using JavaScript, I would pull 2 cards from that array for the dealer, and 2 cards for the player. A response from the API when drawing a card, would look like this: {"success": true,"cards": [{"image": "https://deckofcardsapi.com/static/img/KH.png","value": "KING","suit": "HEARTS","code": "KH"},{"image": "https://deckofcardsapi.com/static/img/8C.png","value": "8","suit": "CLUBS","code": "8C"}],"deck_id":"3p40paa87x90","remaining": 50} So naturally, with blackjack, I just ignored the suites, since they don’t matter. Then, I went through and changed all the KINGS, QUEENS and JACKS value to 10. Finally for the Ace, my thought on that is that, you always want the value of the Ace to be 11, unless your total hand value is over 21, then you’d want the Ace to be 1, since you can choose either value for the Ace. So initially, when I cycle through my initial cards, I want turn all the ACE values to 11. With that in mind, I needed to think about the structure of my game. I really only need 3 buttons. One, for a NEW GAME, which will reset all the values, except for the total wins and losses of each player. One for HIT, which will draw a card for the player. And one for STAND, which will check the values, and draw a card for the dealer if needed. At minimum, that’s really all I need. Here’s how I saw the flow of my game: Initial Values and Arrays: let allCards = \[\];  
  let iterations = 1000000;  
  let player = \[\];  
  let dealer = \[\];  
  let dealerValues = \[\];  
  let playerValues = \[\];  
  var playerSum ;  
  var dealerSum ;  
  let winsPlayer = 0;  
  let winsDealer = 0;  
  let testDeck = \[2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11\]; These are all the values that I’ll be working with in my game. My thinking is that every time cards a drawn or updated, I’ll create a scenario in the background using . With testDeck, I’ll recreate the current scenario of card values, and determine certain game outcomes. The value will determine the number of times I’ll test each scenario, currently set to 1 million. and will contain all the card information for each player. and is an array I’ll push all the current card values to for each player, just to make it easier for me to loop through later. and is what I’ll use to determine current totals for each player and determine winners. and is what I’ll use to keep track of the current number of wins for each player. Finally, once I fetch my cards, I’m going to actually set that value as the value. Since the fetched cards will exist inside the newGame function, I need to access them outside of that function. testDeck iterations player dealer playerValues dealerValues playerSum dealerSum winsPlayer winsDealer allCards HTML My HTML basically looks pretty simple, but I’ll use the , and IDs to create my onclick functions: newGame hit stand <body><div class="navContainer"><div class="title8" id="newGame">new game</div><div class="title11" id="hit">hit</div><div class="title12" id="stand">stand</div></div><div class="title3">Dealer</div><div id="dealerCards"></div><div class="title2">Player</div><div id="playerCards"></div><div class="title4" id="dealerSum"></div><div class="title5" id="playerSum"></div> <div id="currentPercent"></div> <div id="currentBust"></div> <div class="dealerWins"><h1>Dealer Wins</h1><div id="dealerWins"></div></div><div class="playerWins"><h1>Player Wins</h1><div id="playerWins"></div></div> </body> Back to the JavaScript Here are really the only three onclick functions I’ll need, which I’ll create after setting all the initial values. $('#newGame').click(function(){ }) $('#hit').click(function(){ }) $('#stand').click(function(){ }) NewGame After declaring all my initial variables, now I need to set them to 0 or empty. This is because these variables will have values after I push data to them in the newGame, hit and stand functions. I also need to clear the HTML elements innerHTML, since this will be the beginning of a new round. document.getElementById('dealerWins').innerHTML = winsDealer;document.getElementById('playerWins').innerHTML = winsPlayer;document.getElementById('dealerWins').innerHTML = '';document.getElementById('playerWins').innerHTML = '';let hit = document.getElementById('hit');hit.disabled = false;player = [];dealer = [];dealerValues = [];playerValues = [];playerSum = 0;dealerSum = 0;document.getElementById('dealerCards').innerHTML = "";document.getElementById('playerCards').innerHTML = "";document.getElementById('playerSum').innerHTML = "";document.getElementById('dealerSum').innerHTML = ""; Making my API Calls Next, I’ll make a request for the deck and cards: fetch(' {if (response.status != 200) {window.alert("Oh dangit");return;} https://deckofcardsapi.com/api/deck/<<deckID>>/shuffle/').then(function(response) response.json().then(function(data) {let api = data;let deckID = api.deck_id; fetch(' {if (response.status != 200) {window.alert("You done messed up");return;} https://deckofcardsapi.com/api/deck/'+deckID+'/draw/?count=52').then(function(response) response.json().then(function(data) {let firstDeal = data.cards; Next, as I talked about earlier, I need to reset the values of the cards that contain “KING”, “QUEEN”, “JACK” and “ACE”. At the same time, I’ll push those values to my and array. Then, with the cards with correct values, I’ll set the variable to the value of the variable, since it sits outside my function. playerValues dealerValues allCards firstDeal newGame for (var i = 0; i < firstDeal.length; i++) {if(firstDeal[i].value == "KING" || firstDeal[i].value == "QUEEN" || firstDeal[i].value == "JACK"){firstDeal[i].value = 10;}if(firstDeal[i].value == "ACE"){firstDeal[i].value = 11;}if(firstDeal[i].value != "KING" && firstDeal[i].value != "QUEEN" && firstDeal[i].value != "JACK" && firstDeal[i].value != "ACE"){firstDeal[i].value = parseInt(firstDeal[i].value);}}allCards = firstDeal; Drawing cards for each player Next, I’ll need to draw cards for each player. I’ll do that by selecting a card from the array, pushing it into either the or array, and updating both and . allCards dealer player playerValues dealerValues var card1 = allCards[Math.floor(Math.random()*allCards.length)]; let index1 = allCards.indexOf(card1);  
            
          allCards.splice(index1,1);  
            
          player.push(card1);  
            
            
          var card2 = allCards\[Math.floor(Math.random()\*allCards.length)\];  
            
          let index2 = allCards.indexOf(card2);  
            
          allCards.splice(index2,1);  
            
          player.push(card2);  
            
            
          var card3 = allCards\[Math.floor(Math.random()\*allCards.length)\];  
            
          let index3 = allCards.indexOf(card3);  
            
          allCards.splice(index3,1);  
            
          dealer.push(card3);  
            
            
          var card4 = allCards\[Math.floor(Math.random()\*allCards.length)\];  
            
          let index4 = allCards.indexOf(card4);  
            
          allCards.splice(index4,1);  
            
          dealer.push(card4); In the below function, I’ll cycle through the player cards, updated the DOM with their current hand, and update the playerValues with the current card values. With a forLoop, I can re-use this function throughout my code, since it doesn’t matter how many cards are currently in the players hand. It just takes all the cards and updates the DOM and playerValues. However, one thing to keep in mind here, is that, before running this function, you need to clear out the current playerValues and clear the player Cards on the DOM. Otherwise it will simply add to the current total. If you already have 3 cards and your value is 15. Then you add one card and re-calculate, it will add the new card to the current three. For example, if your new card is a 2, instead of a total of 17, your total would be 32 (15 + 15 + 2). for (var i = 0; i < player.length; i++) {card = `<img style="transform: rotate(${randomIntFromInterval(140,180)}deg);-webkit-box-shadow: 3px 2px 32px 4px rgba(0,0,0,0.88);width:100px;height:120px;" src="${player[i].images.png}" />`;playerValues.push(player[i].value);document.getElementById('playerCards').innerHTML += card;} This exact same function can also be interchanged for the dealer, but replacing the dealer variables with the current player variables. Since we are in the newGame function, we don’t need to clear the current values, since they are already empty. But when running the function in either the hit or stand function, we would need to clear the values first. For example, we would do this: document.getElementById('playerCards').innerHTML = "";  
  playerValues = \[\]; for (var i = 0; i < player.length; i++) {card = `<img style="transform: rotate(${randomIntFromInterval(140,180)}deg);-webkit-box-shadow: 3px 2px 32px 4px rgba(0,0,0,0.88);width:100px;height:120px;" src="${player[i].images.png}" />`;playerValues.push(player[i].value);document.getElementById('playerCards').innerHTML += card;} Now, currently this is pretty much the backbone of my game. I’m also adding functions that calculate the percentages, current wins, etc, but this is really the basic format here. In the hit and stand functions, we would simply need to add conditional statements when running this function. For example, after updating the player cards, dealer cards and values, we would check and see if either player busted, or if a player had won the game. Most of my conditions are simple if statements like: if (playerSum > 21 && playerValues.includes(11)==true){ // do something } In this example, when a player draws, and his current total is over 21, we’ll check to see if the player contains any 11’s (which would be the value we set the ACE card to). If it’s true, we’ll get the index of that card, reset the value to 1 instead of 11, and re-update the current values, sums and the DOM. And then of course there are conditional statements to determine a winner: if(playerSum > dealerSum && playerSum <= 21){ } In this example, if the playerSum is higher than the dealerSum, we’ll determine that the player is the winner, so long as the playerSum is also under 21. The most time consuming part of the entire game is probably determining busts and wins, since the player and dealer values, sums and percentages would need to be updated at each condition. I also have this condition that I liked: while(playerSum > dealerSum && playerSum <= 21){} Here, I use a while loop instead of a for loop or if statement. This is inside my stand function. Basically, when a player stands, I want to check the value, and if the dealer value is less than the player value, we’ll just keep hitting for the dealer until he either wins or busts, since the player can no longer hit at that point. Calculating percentages: The last part of this for me was what got me started on it in the first place: determining the probability of certain outcomes. For example, I wanted to determine the probability that the dealer’s hand is higher than the player’s. Since I know three of the cards in play after the initial deal. Basically, this would be a multi part function: 1 Create a simulated deck. 2 remove known cards from the deck. 3 draw a new card and substitute it for the unknown card. 4 If the sum of the new card, plus the known dealer card is higher than the player sum, add 1 to a variable. 5 If the test runs a million times, determine the number of times the outcome puts the dealer hand higher than the players. Here’s how my function looks, turning pseudo code into actual code: function determinePercent(p,d){let percentageOne = 0;let testDeck2 = testDeck;let valP = [];let valD = [];for (var i = 0; i < player.length; i++) {valP.push(player[i].value);}for (var i = 0; i < dealer.length; i++) {valD.push(dealer[i].value);}p = valP;d = valD; for (var i = 0; i < p.length; i++) {  
    if(testDeck2.includes(p\[i\])==true){  
      let index1 = testDeck2.indexOf(p\[i\]);  
      testDeck2.splice(index1,1);  
    }  
  }  
  for (var i = 0; i < d.length; i++) {  
    if(testDeck2.includes(d\[i\])==true && i!=0){  
      let index1 = testDeck2.indexOf(d\[i\]);  
      testDeck2.splice(index1,1);  
    }  
  }  
    
  let dealerValues2 = \[d.pop()\];  
  function getSum(total, num) {  
    return total + num;  
  }  
  let playerSum2 = p.reduce(getSum); let dealerSum2 = dealerValues2.reduce(getSum);console.log(dealerSum2); for (var i = 0; i < iterations; i++) {  
    let dealerCard1 = testDeck2\[Math.floor(Math.random()\*testDeck2.length)\];  
    
    if(dealerSum2+dealerCard1 > playerSum2){  
      percentageOne = percentageOne + 1  
    }  
  }  
    
  let percentageTwo = Math.round((percentageOne/iterations)\*100);  
    
  return percentageTwo;  
} Now, I can run this function at any point in my code, and update it, determining a new probability. Anyway, Hope this made sense and was at least remotely helpful and entertaining. There’s obviously more detail I could go into on some of this, but to avoid having a post that’s more boring than it already is, I’ll wrap it up here. Feel free to reach out if I made some mistakes, or I can answer any questions. Let me know how you like the game, or if you have any feedback or suggestions. Thanks! https://www.linkedin.com/in/ethanjarrell/

BlackJack Application with JavaScript

The Issue of Data Structure and Algorithms You get to to the interview on time. Disciplined character. You had a good run first thing and now your energy is just beyond and over. You are ready to give the best interview session of their lives at Wicked.inc, the company you are interviewing for. You are feeling good about this front end development position you have gone through your cheat sheets and your industry best practices. Your friends truly profess that you are a JavaScript ninja. Your colleagues shout out your praise and lay purple carpets when you walk by. You plunge into the session questions after questions, you are smashing. At a point you seem bored, this is too easy. Big mistake. Its like the interviewer picked on this and decided. Okay time to bring out the big guns. But you weren't ready for big guns, in fact you weren't ready for no guns. First question rolling out of his mouth is something about Binary Trees, you don’t get it. How did we get here? Another questions pops out your way. Sorry. did you say Doubly Linked Lists? now you are sure you are feeling dizzy was there something in that coffee your colleague gave you this morning. Your feet is cold now too. At this juncture you are seriously considering spewing incessantly about how you are a fraud, an impostor, that you didnt really know anything and that thanks to Google all you are is was by doing this => Every time. google.com/search . I think I stretched that a little bit. On the other hand you can totally avoid this. You can start by picking the most popular and pragmatic learning materials based on peer review. That way you don’t waste precious time in this toil. What I will do here with this article is to guide your hand a little and give you a couple of links and what I think about them based on my interaction with them at some point in time. But lets go through an example of what kind of questions you can meet. There’s is this question where you are to write a that returns the in an without using any . They can leave it really vague, because most of the time they aren’t specifically looking for anything super-optimized ( ) or shiny; they just want to see if you can write code. function largest value array native functions Big O-Notations clean From experience self-taught developers struggle with this particular question and still end up not having a working solution to show even after several minutes of toiling. On the other hand an average CS background, it’s undoubtedly a super simple task. But even from the CS Graduates it can still expose some lazy or thoughtless programming. A bad way to solve this is : Using several cases and comparing arr[i] to arr[i+1] inside the loop. if…else The efficiency of that method will be damning and you would know this by understanding what are. Big O Notations A “for” loop can be used for this (Not that efficient but its okay and it works) a. An array.forEach method too, using forEach which is a style of coding familar to programmers. (Interesting and efficient) b. Here is my solution ( ): Pseudo code Set a variable to accept your max value(s) say : As your program runs and accepts and deletes multiple choices as the max value changes. a. var CurrentMax . Pick first element in array as potential max with something like theArray[0] remember that arrays start at position not 1. And then which is set at zero compare it to theArray[0] that holds the value for the first number in that array. b. 0 variable CurrentMax Because this is a normal scenario. We are dealing with Using a , compare the with every array e without starting over from the begining with something like for positive integers. forLoop current max lement ( i=0, i < theArray.length, i++) The Helps us not go back and commit serious Big-0 Notation blunders. i++ theArray[0] is way we check the next big thing from the array using the index. This is good practice since you don’t know the actual details of an array. Set the number from **theArray[something]**if it’s bigger than , iterate through the whole array? d. new max CurrentMax Until array is exhausted will the Loop stop: this invariably means we have found our Max number and it is in . NOT CurrentMax Code We did not use native functions. Native functions are the functions already baked into the language that make it easy to write clean code. Right now we have set the initial max value to 0 What if all of the array elements are negative? What if it’s an array of strings? What if the array is in another array That’s where it gets interesting and then your knowledge of patterns and data structure comes to help. Voila we are done! Resources For Studying Data Structure & Algorithms - Quora 1. CLRS — The classic comprehensive text book on algorithms. A must read atleast once in programmer’s career. 2. Introduction to Algorithms: A Creative Approach by Udi Manber — An excellent book on various algorithm categories. Many interesting questions on web portals as interview questions can be found in this book. Chapter end exercises are an asset. One must attempt the “Creative Problems” section at the end of every chapter. If a programmer wants to know the power of induction as problem solving approach, he must read this book. Strongly recommended. 3. The Algorithm Design Manual by Skiena — Lots of algorithmic problems, and discussions, war stories, related problems, interesting exercises. It helps in modeling a problem in different ways. A must work book for every passionate programmer. Don’t read this unless you have good insight into algorithms. 4. Algorithms by Das Gupta — Precise book on few algorithmic categories, pick any chapter based on interest and attempt end of chapter exercises. 5. Algorithms 4e by Sedgewick — Relatively beginner level book, covers graphs, strings, hashing, searching, sorting, etc. very well. It follows OOP approach in Java. Strongly recommended for beginners, though nothing stops a professional. Web portal containing plenty of interesting exercises. There are other books by Sedgewick on Algorithms. Recommended for data structure learning. 6. Introduction to Design and Analysis of Algorithms by Levitin — An introductory book in algorithm design. Recommended for beginners. One can enjoy the explanation and solving end of section exercises. _On Programming Style:_ 1. Programming Pearls by Bentley — A must read book on design and implementation of computer programs. 2. The Practice of Programming by Kernighan — Written during Unix days, still one of the best resource on program design and implementation principles. 3. Advanced Programming in the Unix Environment by W. Richard Stevens — It covers many Unix internals and kernel level API. It follows an excellent programming style. Stevens books are one of the best in their category. I would say, they stand at the level of CLRS in algorithms category. Highly recommended.

Solving For The Max Value In An Array

Celestine, Segun, Bruce, Mukoshy and I in the process of overflowing the stack!!! For some unexplainable reasons, I already told myself that I won’t write any post related to my but then I saw excellent article. Immediately, I was fired up!!! But then, “2016 in review”, Segun Famisa’s 2016 in review me to me, I was like, NO!!! The next day, after consuming large portions of beef and vegetable from my , I came online. Guess what I saw? inspiring article. mama Ire Aderinokun’s 2016 in review Me to me, again, I was like: Be Calm!!! I would be the on if i said 2016 was ordinary for me. It was incredibly , , and , ! Special Adviser to the Devil Lying Affairs amazing outstanding super-lit OMG Open Source Projects This year I had the privilege of working on a lot of open source projects. At different times last year, some of these projects surprisingly got massive attention. 😱😱😱😱 : A comprehensive hackathon/MVP boilerplate for Laravel web applications. Laravel Hackathon Starter Guard your users against entering dumb passwords in your Laravel 5 apps. Laravel Password: : Curated list of awesome open source crafted web & mobile applications for developers to learn from. Awesome Open Source apps : Laravel 5 Lite Package for . Laravel Paystack Paystack : Motor Vehicle Registration Information Search Portal Library. Mvrd : PHP Client Library for Jusibe SMS REST API Service . Also created a and for it. Jusibe PHP Lib https://jusibe.com Laravel package Notification Channel Library : Atom package: Aurelia snippets using ES6 syntax. Atom Aurelia Snippets : A CLI tool for Hackers, HR Associates, HR Managers and Lazy People to read . 💻 💁 🙋 Linda Ikeji CLI Linda Ikeji : Laravel 5 Package to Detect Users Browsers, Devices, Languages and Operating Systems. 📦 📱 Laravel Identify Me inflicting the community with PHP & Laravel Community with Dev tools. Photo Credit: Mohini Ufelli : Laravel 5 Package that provides a fluent API for states and cities in Nigeria. 📦 🍀 Laravel Ngsc Laravel Quotes: Laravel 5 Package that provides all kinds of quotes from success to to life to DJKHALED for your Laravel app! 🔑 🙏 programming Laravel Emoji: Laravel 5 Package that harnesses the power of PHP 7 unicode features to provide emojis in your laravel app. 😋 A Vue.js directive for sharing page items to twitter. Vue twittershare: : PHP Package to Show beautiful cool ascii faces like ᕙ༼ຈل͜ຈ༽ᕗ in your terminal. Ascii Faces : A Laravel exam project with questions from beginner to expert curated by the community and I. Laravel Exam You can check for a lot more I created and worked on this year on my . Github Account Writing This year I wrote a lot. I had the opportunity of writing over 80 articles, and . technical non-technical These were amongst my most popular articles — . One way to Greatness: Pick Yourself . Jon Skeet — The Chuck Norris of Programming . Build A Universal JavaScript App with Next.js . Bootstrapping a React Project . 5 Things you can do with Yarn . Creating your First Laravel app and adding authentication . How to build your own Youtube — Part 1 (A series from Part 1 to 10) . Build a Customer Service Messaging App in 5 minutes . Multi-factor Authentication in your React Apps . Human beings are Open Source Projects Speaking This year also, I had the opportunity to give talks and offer mentorship at and and I remember the following: local international meetups conferences. In February, I gave a talk on Package Development & Open Sourcery at the Lagos Laravel Meetup . In April, I gave a crazy talk on Continuous Delivery without the drama at the forLoop Lagos Developer event . In May, I gave a webinar talk on You can listen to it and check out the . Rapid Application Development with Laravel Spark. here slides In September, and I gave a talk on at conference in . Segun Famisa(the Chief & Dada Android Master) “Identity Management in Your Apps” DevCraft Nairobi, Kenya ( Left: During my session. Right: Segun, I & a Kenyan developer) In October, Celestine Omin(Senior Technical Assistant at Andela) and I gave on , and in did a talks How to become a better developer Scaling your applications Developer War Stories Accra, Ghana. Ahmed Salifou of PHPOcean recap . Prosper & Ghanian Developers. A few Nigerians too! In October, I was invited to inspire the graduating students at . Valley View University, Ghana Who am I to refuse? Went in there & fired them up!!! Graduating Computer Students of Valley View University On November 4, I was in . I gave a talk on U at Check out the Jos, Plateau State ser Identity Management in Your Apps with Auth0 HackJos . slides . (Left: Giving the talk in Jos, Right: Initiated Developers in Jos into the Auth0 Army) On November 18, I gave an inspiring talk(So, I heard) about at becoming a World Class Developer GDG DevFest South-East , PortHarcourt, Nigeria. Giving the World Class Developer Talk in Port-Harcourt On November 19, I gave a talk about at the debut in . How to become a World Class Developer GDG Asaba event, Delta State, Nigeria (Left: Developers in Asaba, Right: Me giving the talk) was the title of my talk at on November 25**.** Firebase for the Web GDG DevFest South-West , Lagos, Nigeria Giving the talk on Firebase at GDG DevFest Lagos I appeared in on November 26 to give another talk on magically Abuja, Nigeria Firebase for the Web at GDG North Central DevFest . Check out this wonderful video recap of the experience . (Left: Giving the talk in Abuja, Right: Discussing with Musti and a techy) GDG North Central DevFest 2016 In 6 Minutes — Recap I was in from November 28 — December 2 to mentor startups at the week long event. Nairobi, Kenya Google Launchpad Nairobi (Left: The Hotel room was nice, so my mouth couldn’t close, Right: Me at iHub during the event) Work ,Travel & Adventure I worked as a Technical Trainer at until around mid-year 2016. I spent the later part of the year consulting for & . This gave me the opportunity to travel to the for the first time to attend Auth0’s Offsite Annual Event in . Andela Auth0 Cloudinary United States of America Washington Left: Prosper & Auth0-ians chilling, Right: Prosper and Jared Hanson(Creator of PassportJs) I had the opportunity to travel again to the and in U.S.A for Chrome Developer Summit Google Developer Expert Summit San-Francisco. (Left: The Great Addy Osmani & I at ChromeDevSummit, San-Franciso) I also visited Kenya, Ethiopia, Germany and Ghana. Recognition My first in 2016 got me trending for almost 3 weeks on Github top PHP developers. So this happened: open source project _By Christine Magee On Sunday, Prosper Otemuyiwa, lead trainer and developer at Andela's Lagos campus, released his…_andela.com How An Andela Developer Beat Out Facebook On GitHub's Top Trending List - Andela I got featured on . laraveldaily.com _While reading Twitter feed everyday, I see more and more new people in Laravel community. At the same time there are…_laraveldaily.com Top 15 Laravel People to Follow Online - Laravel Daily I was nominated for the along side great developers like Unfortunately it later got cancelled. Still, the nomination really got me fired up. Thanks to all of you that encourage and support me daily. JavaScript Legend Award Eric Elliot, Addy Osmani(Googler), James Kyle(Babel), Dan Abramov(Redux & React), Rob Eisenberg(Aurelia), Wes Bos and Sindre Sorhus . I got featured on . TechCabal _There's a super secret list of the best Nigerian programmers. We, TechCabal.com *collectively beat chests* have that…_techcabal.com Nigeria's Top Programmers as ranked by GitHub I got featured on Code Maven Open Source Podcast. _20:35 Prosper Otemuyiwa Okay, so I...oh my God, I have a lot of plans! I am very much a community person so I...it's a…_code-maven.com CMOS #15: Prosper Otemuyiwa - Laravel I got featured on Developeronfire.com Podcast. _Prosper is a full stack software engineer and writer who's worked on biometric, health, financial and developer tools…_developeronfire.com Episode 195 | Prosper Otemuyiwa - Creating Masters I got featured on . Guardian Newspaper _Fire and Community Prosper Otemuyiwa is a young Nigerian software developer who believes in giving back to the…_guardian.ng The year of the software developer I became a the third & youngest in Nigeria. Google Developer Expert in Web Technologies, _Google Experts are a global network of experienced product strategists, designers, developers and marketing…_developers.google.com Google Experts | Experts | Google Developers Life My Family: Dad, Mum and Siblings were all in good health in this year. I turned 24 in October this year & it was a very memorable experience. I registered my tiny company. I bought my first car this year. 💪✌️ I lost an and a this year. 😢 Well, I upgraded to an and a , sorry Macbook! 🚀🚀🚀🚀 IPhone 6 MacBook IPhone 7 better Machine I did not read any non-technical book this year. 😢 Finally, I met the goddess of sarcasm, an amazing young Architect & most importantly an . I mean, what could be better than having someone constantly poking you to do better & supporting you all the way. Thank you, Elsie!!! Edo geh What about 2017? I’m excited for 2017. In short, I already tagged it the year of excellence. As Uncle already stated, I’ve activated the #beastMode for 2017. These are just a few of my world domination plan in the coming year: Victor Asemota : I want to do a lot more JavaScript, write more dev that will make the developer’s life blissful. Open Source tools : I want to write more technical articles and take my writing to the next level. I’ll endeavour to write and publish 3 books. This is a very herculean task but as they say; Writing if your dreams don’t scare you, then you haven’t started. I want to speak in major conferences, give more powerful & highly entertaining talks in several meetups and conferences. Speaking: I want to travel to at least ! 7 new countries I met so many amazing people this year that I didn’t mention here. I’m thankful and grateful for how you all have helped me grow. Cheers to an amazing 2017. #BeastMode 🙌🙌🙌🙌🙌🙌🙌🙌

Stories, News & Mentions about FORLOOPAI

Forloopai’s Stories on HackerNoon