Dou you want to learn web development but don't have much money to spend on a course?

Don't worry, there are many great YouTubers who are spreading knowledge for free

THREAD🧵

A complete beginner's guide to CSS Grid layout 👇🏻

Thread🧵

Grid is used for making complex web design layouts more easily as it's not so hard to master

Using Flex you can make only 1D layout but Grid gives you full power of creating 2D layout

Let's start

{ 2 / 21 }

First things first, start with giving the display property "grid" to the container element or parent element

{ 3 / 21 }

Nothing will change after adding display: flex; in the parent container becuase we need to define the width of columns. In order to set that columns width we have gird-template-columns property

{ 4 / 21 }

Let's start with defining the width of our columns.

For example, let's say I need two columns of width 60% and 40% respectively

grid-template-columns: 60% 40%;

{ 5 / 21 }

React Hooks are the functions which "hook into" React state and lifecycle features from function components. Hooks allows you to manipulate state and other React feature without writing a class. Let's talk about widely used hook

useEffect hook at a glance 🧵👇🏻

useEffect hook is the heart of React functional components

If you're familiar with class components then you might know that we have various lifecycle methods but in functional components, we don't have any lifecycle methods. Instead we have a powerful hook called useEffect

By using useEffect, you tell React that your component needs to do something after render. React will remember the function you passed (we'll refer to it as our “effect”), and call it later after performing the DOM updates

So let's start by understanding the syntax first

3/15

useEffect take two parameters, first is a function and second is an array.

The function inside the useEffect will run every single time component re-render. Consider this piece of code and check the output in next tweet

{ 4 / 15 }

As you can see in the output the function is executed every single time my component re-render

{ 5 / 15 }

1/ @werat asked about whether the debugger was using the C# compiler or language service in VS 2002. It was not. The debugger has a component called an ‘expression evaluator’ that is provided per language and is responsible for parsing and evaluating expressions when stopped at a

2/ breakpoint. For example, if you type into the immediate window, hover over a variable, type into the watch window, etc. the expression evaluator is involved. The debugger and the language service are actually deeply integrated in a number of scenarios in VS, which may

3/ initially seem surprising. I may talk about more of these scenarios in the future, but to give a flavor, when you set a breakpoint at design time the language service is involved, when you are using Edit and Continue the LS is involved, the range of what is being evaluated

4/ when you get a debugger data tip, completion lists when typing in the data windows or immediate window, etc. Prior to VS 2002, there were distinct debug environments tailored to each target customer (VB/VBA, C++, VJ, VBScript, TSQL, FoxPro, Fortran, etc.). The goals of the

5/ VS 2002 debugger included unifying the debugger backend components and providing a single UI stack that would enable new scenarios (for example, a callstack across languages). Expression evaluators are the architecture that separate the language specific pieces from the

1/The next major problem set in #DeFi is #NFTLiquidity.

It has become very clear that, like fungibles, nonfungibles are their own financial asset class.

One path to see this is to envision the future of NFTs as “liquid

2/Some say that NFTs “shouldn’t be” liquid, yet the innovation process continues.

Just like photography has become much easier to create in the last 100 years, liquid NFTs will surely bring down price points of tokenized digital content but will also open expansive new markets.

3/The key observation is this: #NFTLiquidity is merely a technical problem for #DeFi, and the entire set of economic mechanisms is its solution space.

👉🏻 In particular, because of tokenization, *the NFT liquidity problem reduces to the NFT price discovery problem.*

4/In other words, if we could reliably price a set of NFTs, we could issue a token backed by their reliably priced future resale value.

This is a core mechanism that today is underutilized in the market, and one that — we will soon see — applies to all illiquid assets.

5/Today, NFT price discovery proceeds via three main mechanisms: sales, auctions, and ERC20 fractionalization.

And the fundamental problem with each of these mechanisms is capital efficiency: in each mechanism, participants need to spend *at least* $N to value something at $N.

Linux code injection paint-by-numbers.

Can we launch a process that looks one way to (superficial) auditors but is, in fact, entirely different? (Think process hollowing and the like on Windows).

Firstly, how are processes created and what does related auditing look like?

The most common pattern is fork() → execve(). Where the fork() syscall create a duplicate of the running process context and execve() overlays a copy of the target program onto that context.

After calling fork(), we’ll have two processes, the original one and a new - duplicated - one (with a new pid).

Control will return from fork() to both process instances. In the child process, the return value will simply by 0, in the parent it will hold the pid of the child.

Thus we can determine whether we are running in the child context and call execv() accordingly, while allowing the parent to continue.

Now, let’s take a look at where the auditing hooks lie. From calling execve(), we’ll eventually land up in exec_binrpm().

7 Tactics To Increase Engagement on Your Threads

// THREAD //

People are constantly seeing the same stuff over and over again on their timeline.

This is why you need to learn how to stand out.

When they’re scrolling you need to grab their attention and reel them into something they want to read.

If you think about it, your job is just to get them to click your tweet. Once that’s done, they’ll be reading your other ones in no time.

In order to get them to click you need to show one of these 7 things:
> authority
> experience
> value
> lesson
> mystery
> opinion
> numbers

The easiest way to write headlines based off of these things is to write out your audience’s objections.

Then, indirectly counter their objection within your headline (sounds cool right?).

An old copywriting trick 😉

1. Authority

“Why should I read your thread? What have you done that makes me trust you”

Headline:
“$97,840 in Profit This Month Using This 5-Step Plan to Make Landing Pages”

Authority shows people you know what you’re doing by telling them a true stat/claim.