Function object (implements [[Call]] in ECMA-262 terms)

backend development, building APIs, services & working with relational databases (PostgreSQL, MySQL, etc

Ruby, Go, Python, Scala, Java

contribute to debugging production issues across services, participate in code reviews and arch specs

design, build, and maintain APIs, services, and distributed systems

quality digital closing platform

Domain Driven Design

people to work across companies in multiple roles

authentication pattern

archaic industry that still relies on fax machines and manila envelopes

absolutely massive mortgage market

Let's continue our introduction to React. First, we will take a look at how to render a data collection, like a list of names, to the screen. After this, we will inspect how a user can submit data to a React application using HTML forms. Next, our focus shifts towards looking at how JavaScript code in the browser can fetch and handle data stored in a remote backend server. Lastly, we will take a quick look at a few simple ways of adding CSS styles to our React applications.

1.13*: anecdotes step2

The application still appears to work, but don't implement components like this!

return () => { console.log('hello', who) }

Functions returning functions can be utilized in defining generic functionality that can be customized with parameters.

Now the application has three buttons with event handlers defined by the hello function that accepts a parameter.

The event handler is now the function () => setValue(0).

When the component is rendered the function setValue(0) gets executed which in turn causes the component to be re-rendered. Re-rendering in turn calls setValue(0) again, resulting in an infinite recursion

Once the cause of the bug is discovered you can remove the debugger command and refresh the page.

However, don't do this. As mentioned previously, the state of React components like allClicks must not be mutated directly. Even if mutating state appears to work in some cases, it can lead to problems that are very hard to debug.

Monads

Handling arrays

The application appears to work. However, it is forbidden in React to mutate state directly, since it can result in unexpected side effects. Changing state has to always be done by setting the state to a new object. If properties from the previous state object are not changed, they need to simply be copied, which is done by copying those properties into a new object, and setting that as the new state.

It's recommended to write React components that are small and reusable across the application and even across projects.

Page re-rendering

const { name, age } = props

If you wish to get to know JavaScript deeply there is a great free book series on the internet called You-Dont-Know-JS.

When setTimeout is calling the method, it is the JavaScript engine that actually calls the method and, at that point, this refers to the global object.

However, in this course we avoid these issues by using the "this-less" JavaScript.

When calling the method through a reference the method loses knowledge of what was the original this. Contrary to other languages, in Javascript the value of this is defined based on how the method is called. When calling the method through a reference the value of this becomes the so-called global object and the end result is often not what the software developer had originally intended.

const [first, second, ...rest] = t

Individual items of an array are easy to assign to variables with the help of the destructuring assignment.

const t = [1, -1, 3] const t2 = t.concat(5) console.log(t) // [1, -1, 3] is printed console.log(t2) // [1, -1, 3, 5] is printed

In React code, it is preferable to use the method concat, which does not add the item to the array, but creates a new array in which the content of the old array and the new item are both included.

At this moment, the latest version is the one released in June of 2019 with the name ECMAScript® 2019, otherwise known as ES10.

It is good to remember that in React it is possible and worthwhile to write console.log() commands (which print to the console) within your code.

The console should always be open. If the browser reports errors, it is not advisable to continue writing more code, hoping for miracles. You should instead try to understand the cause of the error and, for example, go back to the previous working state:

It is also possible to write React as "pure JavaScript" without using JSX. Although, nobody with a sound mind would actually do so.

In both cases, we call a property or method on a string primitive, and the engine automatically coerces it to a String object, so that the property/method access works.

The POST request to the address new_note_spa contains the new note as JSON-data containing both the content of the note (content) and the timestamp (date):

obj

bar()

obj1.obj2.foo(); // 42

this.a is synonymous with obj.a.

obj.

However, sometimes you include a third-party library that has different Strict'ness than your own code, so care must be taken over these subtle compatibility details.

so the this is instead set to undefined.

Consider this code:

debugger

caring and empathetic

mission

it This

Observable Definition We're now ready to define closure: Closure is observed when a function uses variable(s) from outer scope(s) even while running in a scope where those variable(s) wouldn't be accessible. The key parts of this definition are: Must be a function involved Must reference at least one variable from an outer scope Must be invoked in a different branch of the scope chain from the variable(s)

The Principle of Least Privilege" (POLP)

"Least Exposure" (POLE).

Declaration and re-declaration of variables tend to cause confusion when thought of as runtime operations. But if you shift to compile-time thinking for these operations, the quirks and shadows diminish.

The actual difference is that let/const declarations do not automatically initialize at the beginning of the scope, the way var does.

There's a common misconception that TDZ means let and const do not hoist. This is an inaccurate, or at least slightly misleading, claim. They definitely hoist.

Thankfully, several of us in the community were successfully able to lobby for JS engines to improve this error message so it more accurately tells you what's wrong!

That works, but it's pointless. There's no reason to declare i in that position with a const, since the whole point of such a variable in that position is to be used for counting iterations. Just use a different loop form, like a while loop, or use a let!

That's re-assignment (not "re-declaration"), which isn't allowed for constants.

for (const i = 0; i < 3; i++) { // oops, this is going to fail with // a Type Error after the first iteration }

const declarations create variables that cannot be re-assigned:

const empty; // SyntaxError

In both cases, a SyntaxError is thrown on the second declaration. In other words, the only way to "re-declare" a variable is to use var for all (two or more) of its declarations.

In other words, this is a case where attempted "re-declaration" is explicitly not allowed!

let studentName = "Frank"; console.log(studentName); let studentName = "Suzy";

function hoisting already took precedence for the auto-initialization.

// let's add the initialization explicitly var studentName = undefined; console.log(studentName); // undefined <--- see!?

var studentName; var studentName; // clearly a pointless no-op! studentName = "Frank"; console.log(studentName); // Frank console.log(studentName); // Frank

Guess what parsing is? The first phase of the two-phase processing! There's no magical mental gymnastics that gets around that fact.

The term most commonly used for a variable being visible from the beginning of its enclosing scope, even though its declaration may appear further down in the scope, is called hoisting.

function hoisting

One key detail is that both function hoisting and var-flavored variable hoisting attach their name identifiers to the nearest enclosing function scope (or, if none, the global scope), not a block scope.

Only functions can be invoked, so attempting to invoke some non-function value results in an error.

Pay close attention to the distinction here. A function declaration is hoisted and initialized to its function value (again, called function hoisting). A var variable is also hoisted, and then auto-initialized to undefined. Any subsequent function expression assignments to that variable don't happen until that assignment is processed during runtime execution. In both cases, the name of the identifier is hoisted. But the function reference association isn't handled at initialization time (beginning of the scope) unless the identifier was created in a formal function declaration.

and it's automatically initialized to the value undefined from the top of the scope.

The typical assertion of what hoisting means: lifting—like lifting a heavy weight upward—any identifiers all the way to the top of a scope

Who bears the responsibility for this vision of discipleship?

Where is this vision applied?

Vision-oriented leaders consider where they are going—clarifying their goals—and then carefully developing and implementing an intentional plan in pursuing those goals.

shall be the means perhaps of raising him to heaven, or sinking him to perdition.

Our children will either hear:“Well done, good and faithful servant...Enter into the joy of your master” (Matthew 25:21).Or they will hear:“You wicked and slothful servant!...cast the worthless servant into the outer darkness. In that place there will be weeping and gnashing of teeth” (Matthew 25:26, 30)

“Let’s raise a generation that is living by faith in future grace,” and it would prompt hearty affirmation. The phrase reminded them of a truth that was meaningful to them, which sparked a zeal for it to be meaningful to their children as well.

These trials are coming for me and you, and for the children in our families, and in our churches. When the inevitable troubles come, we want them to be deeply rooted in the granite truth of the promises of God.

Just so you know what’s in my pastoral mind here, I’m getting you ready to die. I’m getting you ready to suffer.

rightly handling the word of truth

I have purposed, and I will do it

Abide in me, and I in you

ear the Lord your God, to walk in all his ways, to love him,

He will not rest until the children in his care “set their hope in God,” remember “the works of God,” and “keep his commandments.” Psalm 78:7 unites our discipleship activity around a clearly stated vision for our children. It also ignites a passion for that vision.

detailed vision and a commitment from everyone involved to work toward the same goal.

This vision must be shared with everyone who is working on the building so that the vision and ultimate purpose for the building will be fulfilled.

Before construction on a building can begin, it is best to have a detailed vision for what that building will be

God’s people (includ-ing the next generations) are “God’s building” (verse 9

Without a target, those who are investing in the next generation are pointing their “arrows” in various directions and, at times, even in competing directions. Some-times the “arrows” are just aimlessly pointed and are shifted when a new idea or whim surfaces

In Psalm 127:4, the psalmist describes children as “arrows in the hand of a warrior.”

An activity-oriented ministry puts more emphasis on the present, and less, if any at all, on the future. They concentrate more on what they are doing with the children, and less on where they are leading the children

equipped to lead their children to God

fight sin

radically committed

“Pastor, if you give the kids something fun to do, the parents will flock to you.”

to care, comfort, encourage, exhort, reprove, rebuke, equip, instruct; and to stir up one another to love and good works applies as much to children and youth as it does to adults

When children and youth have fun at church, positive attitudes about church are formed that will stay with them the rest of their lives.

He knows that life-time attitudes and convictions are formed early in life, so he inspires the young people in his church to delight in God and form a radical God-centered orientation to all of life

Rather than boring children by repeating simple truths and shallow presentations of the Bible, he wants the children growing up in his church to taste the joy of mining the depths of the Bible and discov-ering wonderful things from God’s Word.

love the Word

big view of God

knowledge

Philippians 2:12-13 provides the key to understanding the rela-tionship between that which only God can do and that which we must do—“work out your own salvation with fear and trembling, for it is God who works in you, both to will and to work for his good pleasure.”

Him [Christ] we proclaim, warning everyone [including our children] and teaching everyone [including our children] with all wisdom, that we may present everyone [including our children] mature in Christ.”

Even though zeal is ultimately a work of God in the heart, I believe there are things we can do that God will use to awaken zeal in us and in others

we can’t make ourselves or anyone else zealous.

Zeal in Scripture is not simply enthusiasm. It is fervor and diligence born out of a passion for God and His glory. It is the result of a heart on fire for the glory of God that is uncontainable and spills out in zealous evangelism, discipleship, service, and good works

The Lord hates the absence of zeal

If we pray earnestly for zeal for the discipleship of the next generation, we can wonder in hope.

What news of your children or grandchildren would be your greatest joy? That they made the soccer team? That they graduated with honors? That they got accepted to Yale? Our world presses us to prioritize anything and everything but that which will truly satisfy. There is no greater joy in this life, or the next, than being reconciled through Christ to God

Investing our time, talents, and resources in the faith of our children and grandchildren is investing in their joy, and not only their joy but ours as well.

Discipleship of the next generation is more than duty.

The urgent, earnest desire to prepare just as thoughtfully and purposefully the children who are facing, or will face, these challenges fuels our zeal

therefore the world hates you.

Zeal for the discipleship of the next generation is also intensified by the desire to prepare children for a world that is increasingly hostile to the truth of God’s Word.

Psalm 78:5

Oh, they get all kinds of knowledge, and it’s leading them straight to hell

Over the next decade, Sally and I experienced a rising, irresistible, and persistent zeal to spread the knowledge of this glorious God and the life-giving truth from His Word to the next generation.

But in the middle of that year, God took me to the church of a new young pastor, John Piper. Thus began what would be more than 33 years under the consistent influence of his faithful expository preaching and biblical teaching.

First, in 1974, I was falling in love with a Christian Education major who was, and is to this day, more zealous for the discipleship of the next generation than anyone I have ever known. God has given Sally an unquenchable and very contagious zeal that He has used to ignite and sustain a zeal in me for more than four decades.

many of whom were not particularly zealous about the discipleship of the next generations when they began their ministry (since people serve in next-generation ministry for many different reasons).

Fight the good fight of faith

Embrace a Biblical Vision”

Would that you were either cold or hot!

present [their] bodies as a living sacrifice,

“love the Lord your God with all your heart and with all your soul and with all your might”

generation known as the Millennials, only 49% even described themselves as Christians. That’s astoundingly low as compared to other recent American generations.”

“that’s what my parents did with me and I turned out pretty good.”

Too many were lacking any plan for instructing their children in the truth.

But the truly surprising behavior is that even though we assigned the number 42 to name (and thus window.name), when we then retrieve its value, it's a string "42"! In this case, the weirdness is because name is actually a pre-defined getter/setter on the window object, which insists on its value being a string value. Yikes!

console.log(name, typeof name); // "42" string

A simple way to avoid this gotcha with global declarations: always use var for globals. Reserve let and const for block scopes (see "Scoping with Blocks" in Chapter 6).

It's almost certainly a bad idea to create a divergence between the global object and the global scope.

window.something = 42; let something = "Kyle"; console.log(something); // Kyle console.log(window.something); // 42

pure.

window.hello(); // Hello, Kyle!

Node also exposes several elements "globally," but they're technically not in the global scope: require(), __dirname, module, URL, and so on.

Second, if you're using a bundler in your build process, all the files are typically concatenated together before delivery to the browser and JS engine, which then only processes one big file.

First, if you're directly using ES modules (not transpiling them into some other module-bundle format), these files are loaded individually by the JS environment.

The code Engine runs

Eliot Sanford

Things I Can Do

Javascript, SQL, Node JS & React JS Sites

Contact Me

Pure HTML, CSS, Bootstrap, jQuery Sites, and Tailwind CSS

Eliot Sanford