Default is a no-code tool that brings engaging form experiences to your company's website

Default

default

Protect People From Themselves: Reducing Default Risks in P2P Lending

If I would have to point out one of the most confusing Dispatchers in the world of Kotlin coroutines, that would be the Unconfined dispatchers. Called with Dispatchers.Unconfined when creating a coroutine scope, this a kind of dispatcher that doesn’t really care. The whole idea of the Unconfined dispatcher is simply to pick up a Thread for no other goal than to simply use it. There is no other criteria involved when using a Thread.Coroutines use a system called green threading or also known as user space threading. We can refer to routines as contructs that are designed to gain control of a Thread, but specifically they are managed by the schedulers to run in platform or system threads. By platform threads, we are talking about the threads accessible by the programming language or higher abstraction that we use in our development environment.When we talk about the unconfined dispatchers, it is important to understand what these terms are. And so let’s get clear to what is green threading and user space threading. These terms are used interchangeably. However, there is a very subtle difference: User space threading is used to emphasize that it is the user that schedules the threads. In other words, this is what we refer to when we start threads via our code. Green threading emphasizes on what goes on behind the curtain. Green threads are also called fibers and these are virtual threads that are multiplexed to be used on top of system threads. This is all something very difficult to visualize. But for the case of the Unconfined Dispatchers this is all we need to know about this part. Being aware of the existence of platform threads, virtual threads and system threads and how they work is important because the platform threads will then perform this multiplexing mechanism onto specific system threads and this is why in Kotlin, specifically, we can find dispatchers specifically to be used with the CPU, the Dispatchers.Default, dispatchers specific for IO operations called Dispatchers.IO and dispatchers specific for single threaded UI , such as Dispatchers.Main for other operations as alternatives to the Dispatchers.Unconfined context. Making tests using the Spring Framework we will very easily come across the fact that the Spring Framework uses Dispatchers.Unconfined. When I made it was generally said that Dispatchers.Unconfined were to be used in tests only due to their unpredictability. this video do not rely on a particular platform scheduling system oriented to a specific kind of Thread, it becomes very unpredictable how coroutines launched like this would perform. There were also mentions of the possibility that Dispatchers.Unconfined could eventually block the execution of the application in production code, but to be honest I have never ever seen that, even working so much with the Spring Framework for server-side programming as I currently do with Kotlin. And to top that up they mention precisely that, because of that risk, all nested coroutines form an event-loop. They explain that in their documentation here: Dispatchers.Unconfined https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-dispatchers/-unconfined.html?embedable=true But hold on. Why is the Spring Framework using Dispatchers.Unconfined in their implementation instead of other Dispatchers like for example the Dispatchers.IO? And why not test this before anything? Well, first let’s have a look at an issue that was opened on GitHub about this: https://github.com/spring-projects/spring-framework/issues/32032?embedable=true I came across this subject when I was casually looking for something else and I bumped into another issue on StackOverflow: https://stackoverflow.com/questions/77810077/controller-code-using-unconfined-dispatcher-by-default?embedable=true Someone had found out that, for whatever reason, the Dispatchers.Unconfined was being used and so I created a service on my GitHub Repo here to prove that: https://github.com/jesperancinha/jeorg-spring-master-test-drives?embedable=true And this service is called car-parts-reactive and that is located in the root directory of the project: git clone https://github.com/jesperancinha/jeorg-spring-master-test-drives.git
cd car-parts-reactive
make b
make run The method we want to have a look at is this one in the controller CarController: @GetMapping("/break")
suspend fun getBreak(): String {
    println("Current Coroutine Context -> $coroutineContext")
    println("Current Coroutine Job -> ${coroutineContext.job}")
    println("Main Coroutine Context -> ${currentCoroutineContext()}")
    println("Main Coroutine Job -> ${currentCoroutineContext().job}")
    println("Current Thread -> ${Thread.currentThread()}")
    return "break"
} This method will print out a series of useful information to the console about the corroutine that has been called. The suspend function marked with the suspend modifier isn’t itself a coroutine, but it can only be called by coroutines in Kotlin. And that’s what happens when we call the method. This way we get access to the coroutine context and checkout what dispatcher is being used. Important to note is that using the currentCoroutineContext() function, we are accessing the coroutine context via a top level function in the kotlinx coroutines library. Using coroutineContext, we are accessing the getter of a value located in the kotlin standard library itself. They don’t share exactly the same implementation.In the root of the car-parts-reactive module we’ll find file generated-requests.http and if you are using IntellJ, you can easily make requests to the application with the code contents: ###
GET http://localhost:8080/break

###
GET http://localhost:8080/keys

###
GET http://localhost:8080/parts

###
GET http://localhost:8080/parts/list

###
GET http://localhost:8080/parts/suspend

###
GET http://localhost:8080/parts/correct When you have the application running, try to run a simple REST request against endpoint : http://localhost:8080/break There should be a result in the console similar to this: Current Coroutine Context -> [Context2{micrometer.observation=io.micrometer.observation.NoopObservation@52c86bb3, reactor.onDiscard.local=reactor.core.publisher.Operators$$Lambda$1234/0x000000080165d210@7166cb50}, MonoCoroutine{Active}@5474a700, Dispatchers.Unconfined]
Current Coroutine Job -> MonoCoroutine{Active}@5474a700
Main Coroutine Context -> [Context2{micrometer.observation=io.micrometer.observation.NoopObservation@52c86bb3, reactor.onDiscard.local=reactor.core.publisher.Operators$$Lambda$1234/0x000000080165d210@7166cb50}, MonoCoroutine{Active}@5474a700, Dispatchers.Unconfined]
Main Coroutine Job -> MonoCoroutine{Active}@5474a700
Current Thread -> Thread[#50,reactor-http-epoll-2,5,main] We can see in all counts that the dispatcher being used is the Dispatchers.Unconfined. If we go back to the issue that was created on GitHub, we’ll see that the answer to why the spring framework uses Dispatchers.Unconfined turns out to be the best solution for their cases, according to them. So what they mean, is that in spite of these dispatchers appear to be limited and restrictive, they apparently, and after testing are actually a very good fit for a reactive framework.Of course this is great to read because it makes it clear why actually, unconfined dispatchers are used in Spring.But let’s go back to the basics. I made a few quizzes about unconfined dispatchers and what I like about it is that they are still quite mysterious to me. And let’s get one thing clear before we move on. There can be some confusion regarding context and scope. Scope refers to where the coroutine is available and context to how it gets dispatched. There can be confusion about this because both terms are quite intimately connected to each other. For example, we cannot create a scope without a dispatcher and they go hand in hand. A scope allows me to launch coroutines with keywords like async and/or launch, but a context is related to how that coroutine gets assigned a Thread.Let’s make two quizzes. We start with this one in this video: https://www.youtube.com/shorts/7Rv_zcT_yPE?embedable=true In this video I show a simple implementation of some code that makes some calls and these different calls will print the words “master”, “mouse” and “cat” in different orders. The code is available here: https://github.com/jesperancinha/jeorg-kotlin-test-drives?embedable=true For this quiz, the code is available here: git clone https://github.com/jesperancinha/jeorg-kotlin-test-drives.git
cd jeorg-kotlin-coroutines/coroutines-crums-group-1
make b And the code is this one: private suspend fun runUnconfinedCoroutinesTest() {
    logger.infoTextSeparator("Unconfined means that all coroutines will execute concurrently on the starting thread in the scope of the parent thread")
    val job = CoroutineScope(Dispatchers.Unconfined).launch {
        launch {
            logger.infoThread("Cat Before thread ==> ${Thread.currentThread()}")
            delay(100)
            logger.info("This is cat @ ${LocalDateTime.now()}")
            logger.info("Cat context $coroutineContext")
            logger.infoThread("Cat After Resume thread ==> ${Thread.currentThread()}")
        }
        launch {
            logger.info("This is mouse @ ${LocalDateTime.now()}")
            logger.info("Mouse context $coroutineContext")
        }
        logger.info("This is master @ ${LocalDateTime.now()}")
        logger.info("Master context $coroutineContext")
        logger.infoThread(Thread.currentThread())

    }
    job.join()
} When we run this code, many things can happen, but one thing we can predict is how the logs are going to work out in the console. One thing about unconfined dispatchers is that they use the same context, same dispatchers, on the first sub coroutines. If these coroutines need to suspend, they may or may not return to the original Thread they were sharing. In the code above they will most likely not return to the original thread. Nesting in coroutines follows some very important rules as mentioned in their documentation: kotlinlang.org So this is the same as saying that the initial call executes in the same continuation in the same call-frame. This also means that the first 3 launches will run concurrently. The launch that logs a cat does this too, but beacause it has a delay, it will resume either in the same Thread or another thread. So this means that Mouse and Master will be the first things to see in the log and Cat will be the last log in the console. We can see all of this in this log sample: This is master @ 2024-03-21T18:49:00.661284475
Master context [StandaloneCoroutine{Active}@6ce139a4, Dispatchers.Unconfined]
Thread[#1,main,5,main]
Master After Resume thread ==> Thread[#1,main,5,main]
Cat Before thread ==> Thread[#1,main,5,main]
This is mouse @ 2024-03-21T18:49:00.703936722
Mouse context [StandaloneCoroutine{Active}@433d61fb, Dispatchers.Unconfined]
Mouse After Resume thread ==> Thread[#1,main,5,main]
This is cat @ 2024-03-21T18:49:00.801217959
Cat context [StandaloneCoroutine{Active}@52c68062, Dispatchers.Unconfined]
Cat After Resume thread ==> Thread[#28,kotlinx.coroutines.DefaultExecutor,5,main] And this explains the answer I give to this quiz on this video: https://www.youtube.com/shorts/MGxvkW0t8QM?embedable=true But moving on. I have another quiz for you and it is this one on this video: https://www.youtube.com/shorts/LEyEJkJA3xE?feature=share&embedable=true The code for this quiz is available here: git clone https://github.com/jesperancinha/jeorg-kotlin-test-drives.git
cd jeorg-kotlin-coroutines/jeorg-kotlin-coroutines-unconfined
make b And this is the class we are discussing: object UnconfinedCoroutineLauncher {
    private val logger = object {
        fun info(logText: Any?) = ConsolerizerComposer.out().yellow(logText)
        fun infoBefore(logText: Any?) = ConsolerizerComposer.out().green(logText)
        fun infoAfter(logText: Any?) = ConsolerizerComposer.out().red(logText)
        fun infoTitle(logText: String) = ConsolerizerComposer.outSpace()
            .cyan(ConsolerizerComposer.title(logText))
    }

    @JvmStatic
    fun main(args: Array<String> = emptyArray()) = runBlocking {
        logger.infoTitle(
            "Unconfined Coroutines scope tests / There are currently ${
                Runtime.getRuntime().availableProcessors()
            } CPU's available"
        )
        CoroutineScope(Dispatchers.Unconfined).launch {
            launch {
                logger.info("Running on context $coroutineContext")
                logger.infoBefore("Siamese Cat is launching on Thread-${Thread.currentThread().name} with id ${Thread.currentThread().threadId()}")
                delay(1)
                logger.infoAfter("Siamese Cat just ran on Thread-${Thread.currentThread().name} with id ${Thread.currentThread().threadId()}")
            }
            launch {
                logger.info("Running on context $coroutineContext")
                logger.infoBefore("Mouse is launching on Thread-${Thread.currentThread().name} with id ${Thread.currentThread().threadId()}")
                delay(20)
                logger.infoAfter("Mouse just ran on Thread-${Thread.currentThread().name} with id ${Thread.currentThread().threadId()}")
            }
            launch {
                logger.info("Running on context $coroutineContext")
                logger.infoBefore("Maine Coon is launching on Thread-${Thread.currentThread().name} with id ${Thread.currentThread().threadId()}")
                delay(30)
                logger.infoAfter("Maine Coon is just ran on Thread-${Thread.currentThread().name} with id ${Thread.currentThread().threadId()}")
            }
        }.join()
    }
} The best way to pick one or more options form the one I give in the quiz, is to look at the order the animals start. In this case the can all start in random orders. However they will all share the same thread because they are just being launched from that call stack. This way, the Siamese Cat, the Mouse and the Main Coon need to share he same Thread number on those calls and so that eliminates already options B and D. The Siamese cat only has a delay of 1 ms and that means that, although seemingly unlikely, option A is still very possible. It is actually very likely that this coroutine starts and ends before any of the other two start. 1 ms is just too much of a short time. We have to consider that possibility as well. And this is why the right answers to this questions are A and C, and this is only one example of that result: Running on context [StandaloneCoroutine{Active}@4de5031f, Dispatchers.Unconfined]
Siamese Cat is launching on Thread-main with id 1
Siamese Cat just ran on Thread-main with id 1
Running on context [StandaloneCoroutine{Active}@691a7f8f, Dispatchers.Unconfined]
Mouse is launching on Thread-main with id 1
Running on context [StandaloneCoroutine{Active}@50a7bc6e, Dispatchers.Unconfined]
Maine Coon is launching on Thread-main with id 1
Mouse just ran on Thread-kotlinx.coroutines.DefaultExecutor with id 21
Maine Coon is just ran on Thread-kotlinx.coroutines.DefaultExecutor with id 21 Find the video answer to this . quiz here My idea with this article is to show some interesting cases I found with . You may find these issues while working with Kotlin coroutines and very likely a lot of people will tell you just to use the Default dispatcher. That can lead to a miscommunication problem. There is such a thing called , which is specific for CPU operations. When people say that when in doubt, use the default dispatcher, they probably do not mean the context. Make sure to double check, because, especially if you are working in server-side programming with certain frameworks, what they probably mean is that you shouldn’t use any specific dispatchers. Most of frameworks like the Spring Framework already offer support to use suspend functions and so your concern as a developer is for the most cases only to implement the suspend functions and not use any specific context. Use the default of course and that is, in Spring, the . Have a good one everyone! Dispatchers.Unconfined Dispatchers.Default Dispatchers.Default Dispatchers.Unconfined Also published . here

They Said to Use the Default Dispatchers but I Found it Was Unconfined

The checkbox is one of the most useful inputs for building dynamic apps with React. In this guide, we will see how to make the checkbox checked (or unchecked) by default. defaultChecked Prop As a React developer, you are probably familiar with JSX. It’s a templating language to easily develop UIs in React. Its biggest advantage is that most elements and development processes are very similar to HTML. Similar to HTML, you can set the attribute on checkbox inputs. It needs to be set to a Boolean value. If set to , the checkbox will be automatically selected. If the value is , or there’s no default at all, the checkbox will not be automatically selected. defaultChecked true false Let’s look at an example: <input type="checkbox" defaultChecked="true" /> This is a simple uncontrolled checkbox. The attribute is set to a Boolean value . In the real world, is often set to a Boolean value from the state, or a complex condition that evaluates to or . defaultChecked true defaultChecked true false Set the Default Value of a Controlled Checkbox in React In most cases, it’s best to create controlled inputs in React. These are inputs that get their value from the state. Changes to the checkbox also update the state. Let’s look at a of a controlled checkbox: live demo import "./styles.css";
import { useState } from "react";
export default function App() {
 const [checkbox, setCheckbox] = useState(true);
 const handleChange = (e) => setCheckbox(e.target.checked);
 return (
   <div>
    <input type="checkbox" defaultChecked="true" onChange={handleChange} />
    <p>Checkbox is {checkbox ? "checked" : "unchecked"}</p>
    </div>
  );
} style="width:100%; height: 500px; border:0; border-radius: 4px; overflow:hidden;" 

 title="clever-ives" 

 allow="accelerometer; ambient-light-sensor; camera; encrypted-media; geolocation; gyroscope; hid; microphone; midi; payment; usb; vr; xr-spatial-tracking" 

 sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts" When it first loads, the checkbox is selected because is set to . defaultChecked true The event handler tracks change events, accesses the current status (checked or not), and stores it in the state. In this case, we do not set the attribute on an input. attribute results in less code and works the same. value defaultChecked We can keep track of the current value of the checkbox and use it for conditional styling, rendering, and other dynamic features in React. For example, you can use conditional styling to implement the dark mode. If you’d like to learn more, check out my . I’ve published several articles about working with inputs in React. React guides with examples

How to Set A Default Checkbox Value in React

One of the key features of the Spring Boot framework is the built-in support for embedded servers. It includes support for embedded Tomcat, Jetty, and Undertow servers. This means you don’t need any external web servers and no need to deploy WAR files anymore. The embedded Tomcat server is available through the dependency. spring-boot-starter-web However, if you want Jetty or Undertow servers then you can include or dependencies. spring-boot-starter-jetty spring-boot-starter-undertow This article explains how to replace the default embedded Tomcat with Jetty or Undertow servers. https://youtu.be/1gEoiMVULt4?si=RVOx-P3o65KPN2-p&embedable=true Replace Tomcat With the Jetty in Spring Boot To use the embedded Jetty server instead of Tomcat, you need to exclude the from and include the dependency. Also, you will need to exclude the default added spring-boot-starter-tomcat dependency. spring-boot-starter-tomcat spring-boot-starter-web spring-boot-starter-jetty For Spring Boot Version 2.x.x For , make the following changes to your file. Gradle build.gradle dependencies {
    implementation('org.springframework.boot:spring-boot-starter-web') {
        exclude group:'org.springframework.boot', module:'spring-boot-starter-tomcat'
    }
    implementation 'org.springframework.boot:spring-boot-starter-jetty'
} If you’re using build tools, you need to add this to your file. Maven pom.xml <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency> For Spring Boot Version 3.x.x The above configuration works for Spring Boot version 2.x, but it will throw the following error if you’re using the latest Spring Boot version 3.x. java.lang.ClassNotFoundException: jakarta.servlet.http.HttpSessionContext 
with Spring Boot 3 and Jetty server This is because Jetty does not yet support Servlet 6.0. To use Jetty with Spring Boot 3.0, you will have to downgrade the Servlet API to 5.0. You can use the property to do so. jakarta-servlet.version Ref: Spring-Boot-3.0-Migration-Guide ext['jakarta-servlet.version'] = '5.0.0'
dependencies {
    implementation('org.springframework.boot:spring-boot-starter-web')
    implementation 'org.springframework.boot:spring-boot-starter-jetty'
    modules {
        module("org.springframework.boot:spring-boot-starter-tomcat") {
            replacedBy("org.springframework.boot:spring-boot-starter-jetty")
        }
    }
} If you’re using build tools, you need to add this to your file. Maven pom.xml <properties>
    <java.version>17</java.version>
    <jakarta-servlet.version>5.0.0</jakarta-servlet.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <exclusion>
                <artifactId>spring-boot-starter-tomcat</artifactId>
                <groupId>org.springframework.boot</groupId>
            </exclusion>
        </exclusions>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>
</dependencies> Replace Tomcat With Undertow in Spring Boot To use Undertow instead of Tomcat, first, you need to exclude the spring-boot-starter-tomcat from spring-boot-starter-web. Then you should add the undertow starter as shown here. For , make the following changes to your file. Gradle build.gradle dependencies {
    implementation('org.springframework.boot:spring-boot-starter-web') {
        exclude group:'org.springframework.boot', module:'spring-boot-starter-tomcat'
    }
    implementation 'org.springframework.boot:spring-boot-starter-undertow'
} If you’re using build tools, you need to add this to your file. Maven pom.xml <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
</dependency> Also published here

Replacing Default Tomcat Server With Jetty or Undertow in Spring Boot 3: A Guide

In today's article, you'll learn how HTML elements are stacked by . default Note, I'll NOT teach you how to change the stacking order of elements (you may use the CSS property for this purpose) but only teach you how things work "naturally". z-index I believe understanding how element stacking works by default will make it easier for you to learn how to control it, a concept I'll cover in a future article. Table of contents Important terms The default stacking order Demo Summary Conclusion Important terms : You may recall from high school math classes the , which is formed by the , and axes. In this system, if you combine two axes you create a two-dimensional . The remaining axis will always be perpendicular to the plane and form with it the 3D coordinate system. Consider the below z-axis 3D coordinate system x y, z plane image You can think of the plane (the blue layer) as the screen you're looking at right now. Since you're facing the screen (you're perpendicular to the screen) you're on the -axis. xy z Although the image only shows one layer on the plane, the plane can contain an infinite number of layers. The overlapping can be total or partial. xy overlapping : Considering the system described above in the context of a web page, is the total or partial superposition of elements. The higher the stack, the closer to the user-facing the screen. Stacking stacking : The element, which is the top-level element of any HTML document, is also known as the . Root element <html> root element : Positioned element A positioned element is an element whose computed position value is either relative, absolute, fixed, or sticky. (In other words, it's anything except static.) : A descendant element is an element that is nested within another element, regardless of how deeply nested. Descendant element : An element that is a descendant of the root element and that has NOT been positioned. Descendant non-positioned element : An element that is a descendant of the root element and that has been positioned. Descendant positioned element : Keep in mind that the element is a container for the and the elements. The former is NOT visible to the user and contains metadata about your page, for instance, it links your page to external style sheets. The latter is a container for the visible portion of your page. Therefore, the descendants of the element that matters to us is the one inside the element. Note <html> <head> <body> <html> <body> The default stacking order Once you understand the terms described above, understanding the default stacking order is pretty straightforward: At the very bottom of the stack goes the element. <html> Then, its non-positioned descendant elements, in order of appearance in the source code. And finally, its positioned descendant elements, in order of appearance in the source code. Demo https://www.youtube.com/watch?v=zac8nGU2RkU&embedable=true <body>
  <div class="static1">Static #1</div>
  <div class="relative">Relative</div>
  <div class="absolute">Absolute</div>
  <div class="fixed">Fixed</div>
  <div class="sticky">Sticky</div>
  <div class="static2">Static #2</div>
</body> You can see from the demo and from the snippet above that both static elements go below the positioned elements when they overlap, even though comes last in the source code. This proves that in this imaginary positioned elements are closer to the user than non-positioned elements. Static #2 z-axis, The way the positioned elements overlap proves that they are stacked in order of appearance. What about the ? root element The next paragraph might blow your mind 🤯 I haven't set any styles to it, which makes it keep its . The white background you see comes from the light your device's screen emits. Don't believe me? See the for the . transparent background-color Formal definition background-color If you set a different to the you'll confirm that it is below its descendant elements. background-color root element Summary The first thing to consider is that, when we talk about , we're talking about a tridimensional conceptualization of pages. Elements are stacked on the z-axis, which is an imaginary axis perpendicular to the screen. stacking HTML Second, in order to understand how elements are stacked by default, i.e., without the property, we need to make a distinction between three types of elements: z-index The root element (the element) which is a container for every other element you add to your page. <html> Non-positioned elements, which have their computed value equals to . position static Positioned elements, which have their computed value equals to anything but . position static Third, stacking will only be observable in cases of overlapping between elements. Fourth, you may not have noticed, but there's no distinction between the different types of positioned elements. By that I mean that absolutely positioned elements do not have precedence over relatively positioned elements or vice-versa, for example. They have the same "weight" and the one that comes later on the source code will be on top. Conclusion Once you understand what means in the context of web pages and the different types of elements that can be stacked, understanding the default stacking order becomes crystal clear. stacking From a philosophical perspective, when you compare the section with the section you can see that learning may be more difficult, but it will make learning the easier. Important Terms default stacking order why how Finally, this article does NOT deal with the stacking of nested elements of a stacked element, nor with how to alter the stacking order, but I promise I'll cover that in a future article 🫡 This project's source code is available at this . Go ahead and give it a star! repo Did you like this article? Share it with your friends, or leave a comment or a reaction. Of course, there's nothing stopping you from doing everything 😄 If you're on HackerNoon, don't forget to if you want to get my latest articles straight to your inbox. subscribe

How Are HTML Elements Stacked by Default?

Solidity's custom errors offer significant advantages in blockchain development, enhancing smart contract robustness and clarity. These errors provide detailed and precise error messages, improving the ease of issue diagnosis. Additionally, they strengthen code readability by allowing for clear naming of error conditions and improve gas efficiency by enabling compact encoding of error information. Embracing these custom errors can revolutionize your Solidity development experience. Let's see how we can use custom errors in our Ethereum smart contracts. Defining Custom Errors In Solidity, defining a custom error is a straightforward process that enhances the clarity and specificity of error messages in smart contracts. To define a custom error, you use the error keyword followed by a unique name for the error. If you want to include specific details or parameters in the error message, add them in parentheses after the error name. error NumberTooHigh(uint256 from, uint256 number); Or we can omit the parameters and define a custom error with them. error Unauthorized(); Using Custom Error Once defined, we can trigger this error using the revert statement followed by the error name and required parameters. This approach makes the code more readable and provides a clear context for the error, aiding developers in diagnosing and addressing issues more efficiently. We can use the' revert' keyword to utilize errors that don't require parameters. Then, we specify the desired custom error name and call it a regular function. revert Unauthorized(); To use a custom error with parameters, we must pass the error name and parameters when reverting, similar to how we would pass them in a function. revert NumberToLow(from, number); Consuming Custom Errors When utilizing a smart contract that has custom errors, it can provide users with more specific explanations of what went wrong. By utilizing libraries such as ethers.js or web3.js, developers have a more effective means of managing and presenting information to users. Using the Remix test environment, we can see how a custom error is present in the log console. TL;DR Custom errors in Solidity can improve the transparency and effectiveness of smart contract code, providing more insightful feedback for developers and smart contract consumers, for instance, using a Web3 library. Adding them to your toolkit can be highly beneficial and reduce gas costs. Links Sample code Custom Errors in Solidity Embracing Custom Errors in Solidity documentation revert

How to Master Custom Errors in Solidity: Beyond Default Messages

In this tutorial, you will learn how to resolve the "SyntaxError: non-default argument follows default argument" in Python. This common error occurs when you provide a default value for one or more arguments in a function definition, and then you place a non-default argument after the default ones. This tutorial will cover the following topics: Understanding Default and Non-Default Arguments Why This Error Occurs How to Resolve the Error Examples and Explanations Best Practices Understanding Default and Non-Default Arguments Before we dive into resolving the error, it's essential to understand the difference between . default and non-default arguments in Python Default Arguments Default arguments are the parameters of a function that have a default value assigned to them. If the caller doesn't provide a value for a default argument, the function will use the specified default value. Default arguments are defined with an equal sign ( ) followed by the default value. = def greet(name, greeting="Hello"):
    print(greeting, name) In this example, is a default argument with the default value "Hello". If you don't provide a value for , the function will use "Hello" as its value. greeting greeting Non-Default Arguments Non-default arguments, also known as positional arguments or required arguments, are the parameters of a function that must be provided by the caller. They don't have a default value, so the caller must always provide a value for them. def greet(name, greeting):
    print(greeting, name) In this example, both and are non-default arguments, and the caller must provide values for both of them. name greeting Why This Error Occurs The "SyntaxError: non-default argument follows default argument" occurs when a with a non-default argument after one or more default arguments. Python doesn't allow this because it creates ambiguity in the function call. function is defined Consider the following example: def example_function(a=1, b):
    pass This function definition will raise a syntax error because the non-default argument follows the default argument . When you and provide only one argument, Python wouldn't know whether to assign the value to or . b a call this function a b How to Resolve the SyntaxError: Non-Default Argument Follows Default Argument To resolve the "SyntaxError: non-default argument follows default argument" error, ensure that all non-default arguments are placed before any default arguments in your function definition. If you want to provide a default value for an argument, make sure it comes after all the required arguments. def example_function(b, a=1):
    pass In this example, by placing the non-default argument before the default argument . we have fixed the error b a Examples and Explanations Let's explore some examples to better understand how to resolve this error in different situations. Example 1: Simple Function With One Default and One Non-Default Argument # Incorrect function definition
def greet(greeting="Hello", name):
    print(greeting, name)

# Correct function definition
def greet(name, greeting="Hello"):
    print(greeting, name)

# Calling the function
greet("Alice") Output: Hello Alice In this example, the incorrect function definition has the default argument before the non-default argument , causing the syntax error. greeting name We fix the error by placing the non-default argument before the default argument . name greeting Example 2: Function With Multiple Default and Non-Default Arguments # Incorrect function definition
def calculate(a=0, b, operation="+"):
    if operation == "+":
        return a + b
    elif operation == "-":
        return a - b
    elif operation == "*":
        return a * b
    elif operation == "/":
        return a / b

# Correct function definition
def calculate(b, a=0, operation="+"):
    if operation == "+":
        return a + b
    elif operation == "-":
        return a - b
    elif operation == "*":
        return a * b
    elif operation == "/":
        return a / b

# Calling the function
print(calculate(5))
print(calculate(3, 2))
print(calculate(3, 2, "*")) Output: 5
5
6 In this example, the incorrect function definition has the default argument before the non-default argument , causing the syntax error. We fix the error by placing the non-default argument before the default arguments and . a b b a operation Example 3: Function With Keyword-Only Arguments You can use the character in the function definition to indicate that all following arguments are keyword-only arguments. This allows you to have default arguments before non-default arguments without causing a syntax error. * # Correct function definition with keyword-only arguments
def display_data(first_name, last_name, *, age=None, city=None):
    print(f"Name: {first_name} {last_name}")
    if age:
        print(f"Age: {age}")
    if city:
        print(f"City: {city}")

# Calling the function
display_data("Alice", "Smith", age=30, city="New York") Output: Name: Alice Smith
Age: 30
City: New York In this example, we use the character to indicate that and are keyword-only arguments. This allows us to have the default arguments and before the non-default arguments and without causing a syntax error. * age city age city first_name last_name Best Practices To avoid the "SyntaxError: non-default argument follows default argument" error in your Python code, follow these best practices: Always place non-default arguments before default arguments in your function definition. If you want to provide a default value for an argument that needs to appear before non-default arguments, consider using keyword-only arguments with the character in the function definition. * When working with a function that has both default and non-default arguments, consider using keyword arguments in the function call to make the code more readable and less error-prone. By following these best practices, you'll be able to write more robust and maintainable that avoids the "SyntaxError: non-default argument follows default argument" error. Python code Disclaimer: The code examples and explanations provided in this tutorial are generated by ChatGPT-4, an AI language model. However, a human editor has reviewed, edited, and tested the content to ensure accuracy and quality. Approximately 60% of the text in this tutorial is generated by human effort to provide a more reliable and coherent learning experience.

How to Resolve the "SyntaxError: Non-Default Argument Follows Default Argument" Error in Python

Cryptocurrency is frequently discussed as a speculative investment, but its main purpose is to function as a mainstream currency. Accepting crypto at your small business could help to competitively differentiate you and might even hold some financial advantages. Is it worth accepting? Small Business Finance and Customer Service It's helpful to think about the possibility of accepting cryptocurrency as providing benefits in two dimensions; first, there are financial advantages, and second, there are customer service advantages. You'll also need to think about the logistical challenges presented by cryptocurrency, but we'll get into that later. From a customer service standpoint, accepting cryptocurrency is all about broadening your appeal and making financial transactions easier for your customers. This benefit is hard to measure concretely, since many of your customers may not know how to facilitate cryptocurrency transactions and may not even know what cryptocurrency is. The Benefits of Accepting Crypto So, what are the benefits of accepting cryptocurrency at your small business? There are millions of people who are crazy about cryptocurrency. They believe that crypto is the future, and they want to use it whenever they get the chance. Accepting crypto as payment in your small business is immediately appealing to them, motivating them to purchase more from you. Appeal to target niches: You already know that accepting many different forms of payment increases your customer base; different people prefer to pay in different ways, and all your customers appreciate your flexibility. Accordingly, accepting crypto by default could be a great way to increase your appeal. Flexible payment options: How many other small businesses like yours are accepting cryptocurrency as payment? If you're the first small business in your niche to do it, you'll have a massive advantage in competitive differentiation. Otherwise, you'll be keeping pace, so you avoid falling behind. Competitive differentiation: With cryptocurrency, you'll never have to worry about chargebacks. You also don’t have to worry about . While cryptocurrency itself is technologically complex, it lends itself to less financial complexity for your small business (once you're over the initial learning curve). Fewer financial complexities: PCI compliance Crypto enthusiasts are proud to extol the security and privacy virtues of their favorite currencies. By using the blockchain, transactions are recorded immutably, and to an extent, these transactions afford users more privacy than they would find in traditional forms of payment. Security and privacy: Though transaction costs fluctuate, cryptocurrency has the potential of providing your small business with reduced transaction costs overall. It's still not as good as cash, which carries no real transaction cost, but if you can save even a few pennies on every transaction, the savings will add up over time. Reduced transaction costs: If you're interested in investing in cryptocurrency, accepting crypto as payment could help your investment strategy. You can convert cryptocurrency into dollars when you receive it, but you can also hold the cryptocurrency in your own account. It's up to you. Investment potential: The Downsides of Accepting Crypto There are also some downsides you'll need to keep in mind. If you've never used or invested in cryptocurrency before, you might not understand how to set up a cryptocurrency transaction system for your business. No matter what, you're going to experience some hurdles and challenges to get your crypto acceptance online. This process isn't nearly as complicated or intimidating as people unfamiliar with cryptocurrency make it out to be, but if you're a total newcomer to this financial product, it's going to take some time for you to build your familiarity. Expect at least a week or two before you feel comfortable with the system. Setup challenges: Many of your customers will be enthusiastic about paying with cryptocurrency, but they may not understand how to do it. And of course, all your customers who are uninterested in cryptocurrency will have no idea how to facilitate this type of transaction. That means you could encounter customers who struggle to pay with cryptocurrency – and you may need to teach them on an individual basis. User confusion: Most . There is a significant upside for investors who can time the market well, and if you believe in the future of cryptocurrency, long-term holds could be a lucrative strategy. But the fact remains that current prices are constantly in flux. If you're planning on keeping cryptocurrency, rather than converting it to dollars, this could be problematic for you. Market volatility: cryptocurrency markets are volatile Managing taxes when accepting cryptocurrency as payment can also become complicated. In addition to properly accounting for sales tax, you'll be responsible for tracking any gains you make by investing in the crypto market. Be sure to keep thorough, accurate records. Taxation ambiguity: Cryptocurrency processing technology doesn't remain static; it's constantly evolving. That means your business may be responsible for making upgrades and process changes in the future. Future updates: It's hard to say exactly what the future of cryptocurrency is going to be, especially if governments introduce new regulations to try and curb digital currency growth. One major negative change could instantly disrupt the balance of advantages and disadvantages in your strategy. Of course, by that same token, a positive change for cryptocurrency could instantly make accepting this currency more favorable to your business as well. The hazy future of crypto: The Bottom Line So, what's the bottom line here? Ultimately, accepting cryptocurrency isn't a total net positive or a total net negative for your business. There are some important challenges you'll need to overcome, and potential benefits you can enjoy, but no matter what, you'll need to carefully consider who your customers are, where your business is, and what you're trying to achieve. Accepting cryptocurrency is an awesome advantage for some small businesses, while it has the potential to hold other small businesses back. We wish there were a simpler answer, but hopefully the details in this article can guide you to a conclusion for your unique business.

Should Small Businesses Accept Crypto by Default?

Hi Hackers, LooksRare no longer supports by default. NFT creator royalties The move comes as a bid to keep up with other exchanges, like X2Y2 and sudoswap, that have already moved to opt-in royalties. This race to the bottom is one symptom of how NFT marketplaces are starting to feel the pressure from market saturation via increased competition. Indeed, speaking of X2Y2, this week the exchange blocked new NFT aggregator Blur from using its API in what boiled down to competitive shielding. Blur sidestepped the block by using the API of Gem, another NFT marketplace aggregator owned by OpenSea, to pull in X2Y2 trades. All that said, is competing with OpenSea, including DeFi giant Uniswap, which acquired its own NFT aggregator in Genie earlier this year to enter and get competitive in this sector. everyone Long story short? The NFT marketplace wars have heated up considerably this year, and right now there’s no slowing down in sight. Look for more struggles for positioning accordingly! In the meantime, thanks for reading everyone. Time to get you caught up on the other big headlines from this week ✌️ -WMP 📣 General NFT News temporarily stalled due to issues with , though the issue is . Lens Protocol Polygon gas limits + relaying now resolved became the latest NFT marketplace to . LooksRare no longer support creator royalties by default , a social media network built on Lens, added . ORB mobile notifications launched an in collaboration with Layer3. Quix NFT Bridging Quest is testing out NFT Tweet Tiles: Twitter indicates that 5 of the top 10 most profitable protocols over the last year have been NFT projects . TokenTerminal OpenSea, Ethereum Name Service, Decentral Games, and Foundation , an NFT marketplace, blocked NFT aggregator Blur from . X2Y2 directly accessing its API 🏆 Digital Collectibles resold for . Genesis Mooncat #1103 35Ξ endured a exploit during its RIMOWA Cabin Luggage mint event: RTFKT loopable transaction 🎨 Cryptoart launched its . Art Blocks new and improved website unveiled PLASTICS, a series created using the new Drops tool by Foundation: Jimmy Edgar , a cryptoart OG, saw his series hit a new ATH of 18Ξ: Matt Kane Gazers , the most popular NFT marketplace on Tezos, added , a popular generative art platform. objkt support for collections from fx(hash) 🎮 Decentralized Gaming rolled out a patch that introduced various bugfixes and seasonal Axieween UI updates: Axie Infinity announced 10k in $GHOST prizes for its festivities. Aavegotchi Gotchiverse Halloween Contest as a sector has fielded over the last year. web3 gaming $6.9B worth of investments 💽 Music NFTs announced its . Catalog second cycle of curators , a platform for free digital collectibles, introduced . Showtime Music Drops unveiled the Sound Market: sound.xyz 🌐 Virtual Worlds is hosting a 5-day event in Decentraland. DAPPCRAFT Halloween Treasure Hunt 💎 DeFi x NFTs rolled out , a straightforward protocol for borrowing and lending NFTs. DeFiLlama llamalend Action steps 💌 Read in (newsletter) Crypto privacy is humanitarian Bankless ⚽ Watch on (YouTube) Scaling Sorare’s NFT platform Bankless 🌱 Watch talk investable impact on (YouTube) Li Jin and Matthew Frehlich Green Pill 🙇 Catch up on my other from this week: Metaversal posts ✧ Optimistic on OPCraft ✧ NFT game design is hard ✧ 5 tips to maintain your crypto privacy Originally published here

LooksRare No Longer Supports NFT Creator Royalties by Default

LooksRare ya no es compatible con las regalías de creadores de NFT de forma predeterminada

LooksRare ne prend plus en charge les redevances des créateurs NFT par défaut

लुक्स रेयर अब डिफ़ॉल्ट रूप से एनएफटी क्रिएटर रॉयल्टी का समर्थन नहीं करता है

LooksRare はデフォルトで NFT クリエイターのロイヤルティをサポートしなくなりました

LooksRare não suporta mais royalties de criadores de NFT por padrão

LookRare Không còn hỗ trợ Tiền bản quyền dành cho người sáng tạo NFT theo mặc định

LooksRare 默认不再支持 NFT 创作者版税

Why Reading JavaScript Is More Difficult When Default Exports Are Used

When developing projects and products in Node.JS, it becomes essential to set the Node.JS version being used on your computer. is a really useful tool for changing your Node.JS version on the fly. . nvm If you need to install nvm, you can learn how to do that here also lets you set the default version of Node.JS so that you don't have to constantly change it. To do that, you can use the command like so: nvm nvm nvm alias default 18.10.0 Before you do that, though, make sure you have the version you want to use installed. You can do that using : nvm install nvm install 18.10.0 If you want to see what versions are available for you to set as your default version of Node.JS, try using , which will return a list likethe one below. It also states which version is set as the default, beside the line. nvm ls default -> node ❯ nvm ls
       v14.15.1
        v16.4.0
       v16.13.2
       v16.14.0
->      v18.3.0
         system
default -> node (-> v18.3.0)
iojs -> N/A (default)
unstable -> N/A (default)
node -> stable (-> v18.3.0) (default)
stable -> 18.3 (-> v18.3.0) (default)
lts/* -> lts/gallium (-> N/A)
lts/argon -> v4.9.1 (-> N/A)
lts/boron -> v6.17.1 (-> N/A)
lts/carbon -> v8.17.0 (-> N/A)
lts/dubnium -> v10.24.1 (-> N/A)
lts/erbium -> v12.22.12 (-> N/A)
lts/fermium -> v14.20.0 (-> N/A)
lts/gallium -> v16.17.0 (-> N/A) Also, running will show you which version you are currently using. If it's not the one you want, you can set it back to the default using : node -v nvm use default ❯ node -v
v16.18.0
❯ nvm use default
Now using node v18.3.0 (npm v8.11.0)

How to Set the Default Node.JS version with nvm

In a previous article, I covered the concept of . In this guide, we used the question mark symbol to denote if a function's argument was optional. optional parameters in TypeScript ? In this guide, let's look at another way of achieving this - with default parameters. Default Parameters Before looking at how these parameters work in TypeScript, let’s recap on how they work in Javascript. Default parameters are already widely supported in Javascript. When we talk about , we are talking about giving arguments values that should be used, if that argument is undefined. For example: default parameters let myFunction = (x, y = "World") => {
    console.log(x + " " + y);
}

myFunction("Hello"); In the example above, since is undefined when we call , the default value is used. That avoids the issue where may be if the user doesn't mention it in the function. If we didn't define here, then the function above would console log . y myFunction y undefined y Hello undefined Why use Default Parameters? The example above is a good reason as to why you might want to use default parameters. Here, we don't want the user to see an value. So we will replace with a default, meaning we never show this to user. undefined y Imagine a similar scenario where we show a user's name. In that example, we might not always have the surname. Here, we could use default values to omit it and not show the text to the user: undefined let showName = (firstName, lastName = "") => {
    return firstName + " " + lastName
} As such, default parameters let us improve a user's experience in some cases. They also can be used in other places, such as setting the default position of a shape on an HTML canvas. Default Parameters in TypeScript Fortunately, there isn't much-added complexity in TypeScript when it comes to default parameters. We can add them into our code in the same way - we must also define the types too. let myFunction = (x: string, y: string = "World") => {
    console.log(x + " " + y);
}

myFunction("Hello"); Here, we expect both arguments to be strings, but actually, we don't even have to give a type. TypeScript's engine will infer that is a string since its default value is a string: y y let myFunction = (x: string, y = "World") => {
    console.log(x + " " + y);
}

myFunction("Hello"); That means that running will still result in a TypeScript error - if we don't explicitly define 's type: myFunction("Hello", 1) even y Argument of type 'number' is not assignable to parameter of type 'string'. Conclusion In conclusion, default parameters can be used the same way as in Javascript. The only additional thing to consider is that we don't have to always define a type on a parameter that has a default value, and if we don't, TypeScript will assume the type based on what the default value is. So if the default value was , then TypeScript would assume that that argument was a . 1 number Also published . here

How to Use Default Parameters in TypeScript

Vue uses provide and inject as a method to send data down multiple levels without having to use - but did you know you can set default values for any injected data, should it not be injected in the first place? Let's look at how it works. properties Setting default values with provide and inject in Vue If you're not sure . By default, expects a default value to be set for a key - and if it's not, it'll throw a runtime error. As such, it's beneficial to set a default value so that a runtime error does not fire. how provide and inject work, you can read about it here inject provide So let's look at an example. Say you some data in your parent like this: provide <script setup>
    import { provide, ref } from 'vue'
    const message = ref('message');
    provide('myKey', message);
</script> If you then inject it somewhere, you can use the second argument to set the default value. For example: <script setup>
    import { inject } from 'vue'
    const message = inject('myKey', 'the default value')
</script> In this example, if cannot be found, the default value will be set to instead. You can achieve the same thing with the Options API like so: myKey the default value export default {
    inject: {
        message: {
            myKey: 'the default value'
        }
    }
} Setting default values for injectors in Vue is best practice, and helps prevent unexpected runtime errors. Also published here.

Setting Default Inject/Provide Values in Vue

Using Metasploit to Attack Default SSH Username/Passwords The Lab Environment This is a simple brute force method to connect to a Unix machine using SSH in our pentesting lab. The target machine, a Raspberry Pi running the Kali Linux OS is up-to-date and no other changes were made to the operating system. SSH is enabled, but in reality, this can be any machine with SSH.  We are using common default usernames and passwords. The machine performing the exploit is Kali Linux on VMWare. The Target Machine The Raspberry Pi is also performing no other daily responsibilities so no additional setup on this machine is required for this test. SSH is enabled during the installation and the system is up-to-date using and . apt-update apt upgrade Getting the Target IP Address If you do not know the IP address of the target machine, you can confirm the IP address of the Raspberry Pi using the or command from the console. hostname -I ifconfig In this example, the IP address of our Raspberry Pi target machine is . You will need this later so write it down. 192.168.1.95 You are done with the Raspberry Pi. It is now just another server on a network doing normal computer things with SSH enabled on Port 22. A secure Linux machine serving up web pages and user accounts on the Internet. This can be any machine, but for this example, it is our target. Setting up the Exploit On our attacking Kali Linux machine, we need to set up some files and configure Metasploit to exploit the Raspberry Pi victim’s server. There is nothing complicated here, just some small attention to detail. To keep it simple, this exploit uses a list of custom usernames and a list of select passwords. Each username and password are on separate lines in their respective files. To keep this test short and interesting, the lists contain common default usernames and passwords for some Raspberry Pi distributions. You can use any dictionary for this exploit, but we are going to create a simple one for this example. Create Username and Password files Our target group of computers in our testing lab are Raspberry Pi’s. We know the usernames and passwords for this exploit are going to consist of default usernames and passwords specific to Raspberry Pi operating systems. You can use the standard Kali password lists like xxx.txt, but that will take a lot longer to run. The success of this exploit is banking on the fact that admins do not change the default login credentials. Using your favorite text editor, create a file containing these usernames. user.txt root admin kali raspberry pi support Feel free to add additional default usernames to this file. This is only an example of using some common default usernames on Raspberry Pi devices. Create a file containing the following passwords, one password per line: password.txt root toor pi kali admin raspberry password password123 Just like the username file, feel free to add additional default passwords to this file. This is only an example of using some common default passwords on Raspberry Pi devices. Save these two files to your local directory. In this example, we are using . /home/kali/data Run a Nmap Scan My homelab for this exploit has a lot of VMs, Raspberry Pi’s, and production machines in service. Most of these have open SSH ports. With this in mind and I’m never really sure how many open SSH ports there are on my network, I’m using the following command to get a feel for the landscape. The flag says only report on SSH and the flag lists only the ports that are open. Closed ports are not included in the output. -p 22 -open kali@Victim-Pi:~$ sudo nmap -p 22 -open 192.168.1.0/24 The results from our scan show that the ssh service is running (open) on a lot of machines. Now we narrow our focus and use Metasploit to exploit the ssh vulnerabilities. We are interested in the or address because that is a Raspberry Pi and the target of our attack. nmap Victim-Pi 192.168.1.95 Our attacking machine is the or kali-server 192.168.1.207 Raspberry Pi. Using Metasploit From the ( ) command line, launch Metasploit by typing . kali-server 192.1681.207 msfconsole Metasploit provides a search engine to help us select the best exploit to exploit SSH. Entering the command shows us all of the ssh options. search ssh Scan through the output for the ssh vulnerability. For this exploit we want to use Menu Item #21 — which uses brute-force SSH login credentials with our and files we created in . Note that your menu item number most likely will be different. ‘use auxiliary/scanner/ssh/ssh_login’ username.txt password.txt /home/kali/data Enter ‘use ‘ at the msf6 > prompt. You can also enter the menu number (for example: msf6> auxiliary/scanner/ssh/ssh_login use 21 Type and / . set USER_FILE /home/kali/data/username.txt set PASS_FILE home/kali/data/password.txt The next two options, stops execution when there is a successful username/password combination and prints all status messages to the console. set STOP_ON_SUCCESS true set VERBOSE true The command configures Metasploit to use the target machine. This is the same IP address (192.168.1.95) of the machine we issued the or commands earlier. set RHOSTS hostname -I ifconfig Use the command to view additional configuration options advanced You can change any of these options for your situation, but we want quick access to the shell so . set GATHERProof false All of our configuration options are set, run the command to start the exploit. exploit After several failed login attempts, notice the entry. This line reveals that there is a successful username of with a password of combination. [+] 192.168.1.95:22 — Success ‘pi:raspberry’ pi raspberry The option we set earlier tells Metasploit to stop the attack when there is a successful username/password combination. set STOP_ON_SUCCESS true Successful Login We have now successfully logged into the Victim-Pi machine using default login credentials. Type the command to see the active Metasploit sessions. sessions Connect to the current active session, enter the command. sessions 1 At this point, you can use Unix commands as if you were a regular user of the system. To get better control of our exploit type the command to get access to a bash shell. shell Now that you have access you can use Python, Perl, and other system resources to complete your exploit. bash shell How to Prevent this Type of SSH Attack on your Network. This is a brute force attack on a common vulnerability. To mitigate your exposure you can perform the following actions. Educate users on proper usernames and passwords Disable default username/passwords Disable SSH Prevent multiple login attempts Also Published Here

Attack Default SSH Username/Passwords Using Metasploit

Following the emergency meeting, members of the ECB promised to provide all the necessary support to under-pressure eurozone sovereign bonds. On top of that, officials presented a more flexible approach to reinvesting financial instruments accumulated during the pandemic in order to keep the transmission mechanism of monetary policy working. Does it mean that the risk of fragmentation is gone? Considering the upcoming rate hike, as well as deteriorating economic conditions,  the answer would be most probably not. Let’s start by saying that the ECB's main task is to ensure price stability and not to provide favorable financing conditions. Keeping spreads low, on the other hand, could lead to so-called , whereby government debt (some of it) is bought by the central bank. monetary financing Now what? Last week that keeping borrowing costs under control for more indebted eurozone members is "core" to the regulator's mandate. Fun fact - back in 2020, Lagarde said that it was not the ECB's task to "adjust spreads". Christine Lagarde said As for the macroeconomic outlook, the region's annual inflation rate is expected to be 6.8% for 2022, 3.5% for 2023, and 2.1% for 2024. Lagarde also warned of the risk of a correction in Europe's financial and housing markets. Who could have thought that the bubble would burst… In my opinion, things might get way worse than a simple market fall. The reason is very simple - growing social instability in “the old continent”. Over the last few weeks, there have been protests in several EU countries. In particular in Belgium over rising food and petrol prices. In the UK, the transport union RMT calls for wage increases and the avoidance of planned redundancies. Overall, the trend is clear. Another blow to the EU could be Macron's loss in parliament. For the first time since 1988, a newly elected president has failed to win a majority in parliament. Macron's supporters will now have to negotiate a permanent coalition with the Republicans or forge ad hoc alliances with other political forces to get legislation through parliament. Of course, France is not Germany, still, it is the world's seventh-largest economy by 2022 nominal . figures Following the debt market. Talking about the forecast, Fitch Rating's analysts their forecast for institutional leveraged loan defaults in the US by 25 bps to 1.5-2% at the end of 2023. Fitch does not rule out that the default rate could rise to 2% or more in 2024 if the challenging economic backdrop leads to a downgrade in corporate ratings. Total loans "of concern" amount to $178.0bn (+8% QoQ). raised Most likely, will be to avoid a technical recession in case the Russian president decides to cut off gas supplies to Europe before the region has managed to replenish storage levels. Eurozone unable Already now, the Euro Area is signs of faltering as the tailwind of pent-up demand from the pandemic is already fading, having been offset by the cost of living shock and slumping business and consumer confidence. showing Final remarks In order to understand the perspectives of the European economy, I would recommend looking at what “big investors” do. If rumors don’t lie, hedge fund Bridgewater Associates made a large bet on the fall of European stocks. To be more precise, the company increased its shorts in ASML Holding and TotalEnergies, , Vinci, Schneider Electric, Air Liquide in France, Bayer, Munchener Re, Allianz, Vonova, Infineon, Deutsche Börse, and BASF in Germany, Iberdrola, Banco Bilbao and Banco Santander in Spain, ING in the Netherlands and Intesa Sanpaolo in Italy. The moral of the story is? Don't let the market fool you, “headwinds” will only get stronger. BNP Paribas

Prospects of European Economy: Defaults, Bankruptcies, and Debt Crisis

A lesson in human nature from scaling a global fitness app to 40 million people. A brief history in time… Tony Robbins “10% of people that purchase a non-fiction book make it past the first chapter.” — May 2019. I run my morning route through the Englischer Garten in Munich. Tony Robbins finishes that sentence, and I open my notes, writing it down. It’s a bold statement, and it feels true. Months pass, and it is now December 2019. I reflect on the year. I’ve learned many things, but there’s one insight that I can’t let go of: failure is the default. Mining for insight December 2017. I know nothing about what makes a fitness app great and aim to change this by interviewing over 40 people. I want to know what they like dislike about their current fitness routine. and I listen to people that use competitor apps and some that quit apps completely. Listening to their stories, I spot the tension between autonomy and variety, and a desire for accountability. Those with no routine celebrate the freedom but complain that they’re not making progress. Those with a set routine complain of monotony. Everyone has their own motivation, or at least the one they’re willing to admit to a stranger. Young men want muscles and aim to show them off. New mothers want a moment for themselves when their newborn is napping. Women want to feel good and avoid high school acquaintances staring at them in the town gym. The digital gym I spend the next two years building a team of 21 product managers, designers, and researchers. We come face-to-face with the contradictory nature of human intent and reality. We experiment, tailoring the first fifteen minutes of the experience using data from ads and answers to questions like experience level, fitness goal, and gender. We learn from millions of people. We empirically learn the obvious: people like pictures of people like them, helpful default settings rarely get changed, and personalized wins over generic. Most sales happen in these first minutes, and like all good salespeople, we get better at making it easy for people to say yes. But the easier we make it to say yes, the less likely the customer is to start their fitness habit. Another chart tells a similar story: 50% never return to training after month one. We ran a digital gym. We assume these customers will cancel their subscriptions. We’re wrong. The majority keep their subscription because they intend to get started. They just haven’t started . yet Building the habit We throw reminders, stats, community, and other gamification tricks into the app to help people on their journey. Seventy-two experiments later, nearly 70% of customers start a workout in their first week. It’s an achievement. But, after years of experimentation, here’s the reality: 10% of new people will start working out with the app — for free or with a subscription — and you work tirelessly to shift the mix of free to paid Of those people, only 15% will finish a 12-week fitness program Said differently: for every 1,000 people that sign up for your fitness app, only 15 will finish a 12-week training plan. I who trains in waves. He’s fit, successful, and French. He trains with the app 3–6 months out of the year. Every year, for years. The rest of the time, he climbs mountains and enjoys the beach. He always comes back and never cancels his subscription. Being someone who trains is part of his identity, even when he isn’t consistently working out. interview a loyal customer And he likes discovering new features when he comes back the following year. The game isn’t a . perfect workout retention chart The game is keeping the dream alive. But sweating is hard I wonder if it’s just us. I reach out to others in the business of self-development apps. Learning a new language, playing a new instrument, or learning new skills for work. It turns out it’s all the same. We all see the highly seasonal patterns — New Years — followed by drops in activity. The narrative is the same: people intend to start something new but find it difficult keeping the habit. We all share stories of throwing the kitchen sink of behavior change tricks to attempt the seemingly impossible. hello But social media is easy I learn of similar engagement patterns on Reddit and . While it varies by platform, it is said that: other social media platforms 1% of people generate the most engaging content 9% of people generate the majority of content engagement, and 90% of people just lurk Posting content on the internet is hard too. Inertia in play I never find any corroborating evidence to support Tony Robbins’ quote, but I never doubt its accuracy. It fits the narrative built from other data points I have accumulated over the years. New Years Resolutions — 92% of people don’t achieve their goal Open Online Courses — 87% of students don’t complete the class Savings — 69% of Americans have less than $1,000 saved Gym Memberships — 67% (or more) go unused The Digital Gym — 85% of people won’t finish a 12-week training plan We tend to relegate inertia to physics, but it’s evident in human behavior. It takes a lot of energy to build momentum on both the cellular and psychological level. Often, it’s easier to keep doing what we’re already doing: nothing. A world (or at least, a nation) of contradiction Americans spent $67 billion on gym memberships and supplements, and the per American was $286. average monthly health and fitness spend If you only analyze spending, you might conclude that Americans are the healthiest, most fit inhabitants of this planet. Unfortunately, CDC data shows 74% are overweight, and 43% are obese. Doing hard things is hard, and most people don’t do hard things. Or at least, they don’t finish them. Sometimes — — you’re going to fail. . most likely The default is failure Just don’t give up.

The Default State is Failure - Don't Give Up!

When we use components in Vue, we often use properties or props to pass custom pieces of data down to the child component. For example, we can tell our child component that for this version of the component, "name" is set to "my-component": <Component name="my-component" /> If we try to call this component without a prop, it returns in the code, or just as no text when rendered in HTML. Let's say our looks like this: name undefined Component <script>
export default {
    props: {
        name: String
    },
    mounted() {
        console.log(this.name);
    }
}
</script>

<template>
    <p>
        Hi {{ name }}
    </p>
</template> All our component does is it defines a prop called of type , and console logs this property. It also displays it in the form . The only issue here is that if is undefined when the component is called, no default name is given. name String Hi {{ name }} name How to set default prop values in Vue using the Options API? Setting default prop values in Vue is easy. If you are using the Options API, then it's as easy as extending our property into an object. For example, if we want our to have a default value of " ", then we update our prop to look like this: name there export default {
    props: {
        name: {
            type: String,
            default: "there"
        }
    },
    mounted() {
        console.log(this.name);
    }
} Now if no name is given, the message will simply say ' '. Hi there How to set default prop values in the Composition API? In the composition API, defining props uses the function. This function follows the same syntax as props defined in the Options API. defineProps Defining a prop without a default looks like this: import { defineProps } from 'vue';
  
const props = defineProps({
    name: String
}); And then to add a default value, we extend to having a default property, just as before: name import { defineProps } from 'vue';
  
const props = defineProps({
    name: {
        type: String,
        default: "there"
    }
}); How to set prop as required in Vue? To avoid the need for setting a default value on a property, we can force a property to be required by using the field. required For example, if we want our property to be defined, we'd simply set to : name required true &lt;script setup>
import { defineProps } from 'vue';
  
const props = defineProps({
    name: {
        type: String,
        required: true
    }
});
</script> Also Published Here

How to Set Default Value of Props in Vue?

¿Cómo establecer el valor predeterminado de los accesorios en Vue?

You’re a writer, maybe a gamer? Perhaps a sound engineer, and you are working tirelessly on that new side project. Suddenly you get this message: “Oops! something went wrong…” Now if we’re being honest, these types of messages are not useful at all. Is it? I mean, look at it. Oh, this isn’t your first time? Aha! Well, guess what? Linux provides you with precise error logs that tell you what caused the error. (Don’t deny it, buddy. You don’t see this anywhere.) By knowing what went wrong, you can now precisely search the Internet for a solution to the error. Now, to the more interesting part. Did you know? Linux has been around since the mid-90s and has since reached hundreds of thousands of user-base around the globe? Bro. Linux is actually everywhere! It’s in your phone(s), thermostats, in your cars, televisions, etc. It also runs most of the Internet. Yup, you heard that right. Stop with the rumbling, bro. What is Linux? Just like *sick face* Windows, iOS, macOS. Linux is an operating system (a kernel, if I’m being very honest). An operating system is software that manages all the hardware resources associated with your desktop or laptop. To put it simply, the operating system manages the communication between your software and your hardware. Without the operating system (OS), the software wouldn’t function. Why use Linux? You’re still asking that? Why bother learning a completely different computing environment, when the operating system that ships with my PC works just fine? I’ll be answering your question with another question, buddy. Now. Does that operating system you’re currently using really work just fine? Or... do you battle with stuff like viruses, malware, slowdowns, crashes, costly repairs, and licensing fees? Hahaha! *evil laughs If you struggle with the above, Linux might be the perfect platform for you. Linux has grown into one of the most reliable computer ecosystems on the planet. Combine that reliability with zero costs of entry and you have the perfect solution for a desktop platform. No kidding, my friend! Zero cost of entry… as in free. You can install Linux on as many computers as you like without paying a cent for software or server licensing. So yeah, so.. why Linux? Linux is completely an project. You can have a look at the source code of a Linux OS, which is a plus. I know, most people don’t care about this openness of Linux, but to me, this is the most important feature of using GNU/Linux. Open source: open-source Linux is a highly reliable and secure system than any other operating system (OS). Linux and Unix-based OS have fewer security flaws, as the code are reviewed by a huge number of developers constantly. And anyone who has access to its source code. So, you won’t need any anti-virus software to protect your PC from malware and viruses. Secured: Windows-powered systems require higher hardware requirements. As the OS grows, with the latest Windows systems, your ancient hardware-supported PC may become obsolete because it won’t support your old hardware. Whereas, with Linux, you can install it on very low-end hardware systems. Works on an older generation of computers: The package manager of Linux is way more robust than any other OS. Installing software in Linux is notably easy compared to Windows. It can enhance the workflow for programmers remarkably. Perfect for Programmers: Microsoft pushes a software update when it receives a set of problems or if something major needs to be fixed. And, for this reason — your system potentially breaks with an update or you end up waiting for an update to fix your issue for a significant amount of time. Software Updates: If you use windows, you need to buy it or use a crack version of it, like a thief. It just doesn’t feel good after a certain age when you use something unethically when there is a free better OS is available for you. Free to Use: Linux community is loyal to all the Linux users so it would give Long Term Support, unlike the Windows community which recently stopped giving support for Windows 7 users so for any bugs or data breaches in Windows 7, you cannot contact Windows help centers. Better Community Support: If you have ever used Windows 10, you could only head into the privacy settings to know default enables everything. Even if you opt-out to send Microsoft information about your data, it is still being collected. Of course, Microsoft will not bother revealing it officially with a press statement, but it surely does. So, you would need a set of tools to disable the spying modules of Windows. Privacy: Conclusion If you’re looking for one of the most reliable, secure, and dependable platforms for both the desktop and the server, look no further than one of the many Linux distributions. With Linux, you can assure your desktops will be free of trouble, your servers are up, and your support requests are minimal. There, you get to be a god and have the power to control your internet privacy and security! First Published here

Stories, News & Mentions about DEFAULT

Default’s Stories on HackerNoon