I'm going to comment with the preface that I gave up reading the article. It feels like a word-salad, and I'm getting lost trying to find the point a lot of the time.
Christianity is Jesus Christ substitutes the sin of a faithful man or woman with His righteousness.
You cannot buy faithfulness, and you cannot obtain righteousness through good works on your own.
The target has never been against wealth, but the love of money, or trusting in the things of this lifetime. For instance, Proverbs 11:28 says not to trust in wealth. Mark 8:36, Jesus states that if you seek wealth over everything else, what good is it when you die? In 1 Timothy 6:17-19, Paul encourages Timothy in his leadership to instruct wealthy people to not put their hope in their wealthy, but to do good with what God has given them.
I came here to say just this. When the word "turbo" and phrase "zero distractions" are present, but the demo is a number of minutes long, it feels like something is wrong.
No its not. Its a good video, just bad place for it. I watched it and got to understand your product.
You show the important part in the time frame ~6:00-7:00. Make that part faster and as a gif without sound and the main message is conveyed
It sounds like as a tech lead, if you're in charge of some degree of scheduling, and you have other tech people that you barely interact with, maybe you could start some sort of weekly or bi-weekly "meeting of the minds," and have a place to bounce ideas around. Even if your work isn't closely related, I bet they also feel a bit of isolation, too. It's likely in your work's best interest to have some common/shared knowledge for a small tech team in case of some sort of tech emergency.
If you were ever looking for "good" Christianity. I attended a bible college in Canada, and to put it politely, I was heartbroken over the types of people who were being trained to lead and manage churches. I'd say a good majority of them were sent by their parents rather than on their own initiative; they were culturally, ethically, and spiritually not Christian. I'm not perfect, either, but you expect a certain level of effort to be put into spiritual and theological mental investment, which unfortunately was not the case.
After that experience, I basically left the church for 10 years, I was so frustrated with many human-related aspects of the church, and I knew I couldn't sit under the leadership of the types of people I went to college with.
---
Now, to answer your first question, yes there is value. In the same way I'm a programmer, but I don't care about the historical authenticity of who actually discovered the Pythagorean theorem. Some people care, and I think that's great, that's an area of interest for them. Now, the flip side is, Christians should care that they can trust the documents that form the basis for their beliefs.
For your next statement, "most of the students were bored and frustrated...didn't want to know anything about the texts themselves," a person who has no historic knowledge of the scripture should never be a pastor. It sounds like you went to university with people who liked the idea of being a respected leader, and the power that comes with it, and you'll find people like that everywhere, even in your secular workplace.
If you truly believe Christians are extremely anti-intellectual, you need to remember, basically every educational organization (ie even secular universities) were originally founded by Christians in the western world, and many of them were likely far more intellectual than you or I. What's crazy is you can also find extremely anti-intellectual non-Christians, too - there are anti-intellectuals everywhere. Typically big sweeping statements like this are from hurt people, and that's horrible that people claiming to be part of the church were so destructive on the things you previously believed.
There are a lot of bad apples in the bunch, even the bible says a little leaven will work it's way through the whole dough [1] [2].
My biggest gripe with async await is when it's used by people that don't understand promises. They interpret await as "let promise run" and not "this blocks the flow." I had someone show me code where they wanted to preload a bunch of images, and effectively had a for loop and did an await on each image in it, effectively running it as slow as possible. I showed him `await Promise.all(imageLoadingPromises)`, and he was confused why we needed `Promise.all` here.
I also don't like how async/await ends up taking over a whole codebase. Often making one function async will cause you to update other functions to be async so you can do proper awaiting. We literally exchanged callback hell to async hell, and said it was better, but I'm not strictly convinced of this.
It's not async/await that takes over a codebase, it's the async nature of functions period, no matter if you're using async/await, Promises, or callbacks.
Callbacks still have the function coloring problem: If you write a function which calls another function with an on-complete callback argument, then your function (usually) has to also take an on-complete callback in order to represent completion.
async/await makes this nicer, but it doesn't eliminate the underlying need to thread async completion all the way up your call stack.
> I also don't like how async/await ends up taking over a whole codebase. Often making one function async will cause you to update other functions to be async so you can do proper awaiting.
This is basically the function coloring problem. There was some ardent discussion about this a few weeks ago on HN [1], where the top comment positioned function coloring as a feature, because it highlights where expensive operations like IO might potentially be happening in your application.
I saw a comment recently where someone pointed out an old API in Java where comparing two URLs for equality initiates a DNS request, and so something as simple as putting a URL in a hash table could end up involving a network request [2]. So maybe it's reasonable to color functions that connect to the network at the very least. If I used a URL comparison library and it returned a promise it would immediately set off alarms in my mind.
That could be much better solved through coeffects, but unfortunately most languages don’t support that. Doesn’t mean using async functions is a good way for this either
> That could be much better solved through coeffects
It's possible, but I can't thoroughly evaluate coeffects until they land in a mainstream language with production usage. What I do know from experience is that you can't quietly block the entire thread on a network request in some innocuous looking function in JS. You have to return a promise and then the calling function has the option to await that promise, but I'm sure the academics in their ivory towers have theorized about something better.
This looks pretty cool. One issue I have from just a cursory glance is that the IO capability includes things like `print` and `echo` [1]. If the context system can't differentiate between `console.log` and `fetch`, then it's a little less useful for me.
If there was a way for users to define their own coeffects then you could sidestep this issue, but I saw this quote in one of the design documents: "Runtime will have a native knowledge of each co-effect. We will not allow co-effects to be defined in user-land code [...] An important aspect to note here is that certain co-effects that need deep support from runtime such as io and pure will need to be implemented in the runtime" [2].
Hack is custom made for facebook and its use cases, and there’s no use for distinguishing those kind of IO at Facebook. The main use case for the effects system is actually privacy, wherein where processes that aren’t privacy controlled cannot access user data or data that got processed by other functions that did. And that’s enforced by the runtime. It’s super cool and a great example of what those systems are capable of.
>We literally exchanged callback hell to async hell, and said it was better, but I'm not strictly convinced of this.
It's obviously better. It's a bit unfortunate how much the history of the design decision shines through in the current solution, but it's unequivocally an improvement.
I would prefer an approach where calls to "async" functions are implicitly awaited unless a keyword turns then into a promise, and all functions are implictly treated as async as needed, unless a keyword specifies that they return a promise, which should be awaited instead. This would make the majority case clearer, and force you to make the minority case explicit where it's currently implicit.
I don't think this would help your coworkers who don't understand promises very much though.
> I would prefer an approach where calls to "async" functions are implicitly awaited unless a keyword turns then into a promise, and all functions are implictly treated as async as needed, unless a keyword specifies that they return a promise, which should be awaited instead. This would make the majority case clearer, and force you to make the minority case explicit where it's currently implicit.
This is a very interesting idea and feels good in an initial 'gut check' sense.
That's basically how goroutines work in Go. You opt into concurrency with the `go` keyword, while it's blocking by default. While in JS it's concurrent by default and you opt-in to blocking with the `await` keyword. (Except in Go you have true parallelism for CPU-bound tasks too, while in JS it's only for I/O)
Both have their pros and cons. I've seen problems in Go codebases where some I/O operation blocks the main thread because it's not obvious through the stack that something _should_ best be run concurrently and it's easy to ignore until it gets worse (at which point it's annoying to debug).
I prefer the raw promise syntax. It makes the promise chain look more like what it is, an asynchronous pipeline, and you don't need to litter async everywhere.
const myAsyncThing = async (init) => {
let value = await task1(init);
value = await task2(value);
return value;
}
const myPromiseThing = (init) => task1(init).then(task2)
I know this is a relatively simple and contrived example, but there are some times where async/await very much is bulky and gets in the way of just writing code.
I didn't write it like that because it obscures the call order. I wasn't trying to compare code line/count, just flow control and readability, which is certainly subjective.
If this "obscures the call order" then isn't that a problem with the programming language in general? If these functions weren't async, would you also not be willing to use g(f()), as that "obscures the call order"? (I certainly have met people who do.) If we aren't going to use function calls, and we also do not want to put these functions on separate lines as that is "bulky", then are we going to argue that we should have something similar to .then() for synchronous code?...
My argument here is that JavaScript is -- as well as most languages we use these days are -- fundamentally designed around the syntax of a function call, and so if you program in such for very long at all you get used to reading "inside out, right-to-left", as that's how function calls work. If we do not like inside out execution order, then we should fix the entire language (by using suffix notation... fwiw, I'd be totally on board ;P), rather than narrowly complain about it only in code which uses async/await and fixing it by abusing the OOP this argument exception to the ordering rule.
(I would also point out that the special syntax order exception you are relying on only works for a single argument, and so if you have to pass task2 both the result of task1 and a second argument to configure it, the usage of .then() breaks down unless we have a way to curry arguments, which we can always simulate using JavaScript's bind(), but at some point we are really going far out of our way to avoid coding using function calls, despite being in a language which relies on them everywhere else.)
At the end of the day, I am just looking for some consistency, so I can quickly and easily interpret what code does no matter whether it is synchronous or asynchronous and whether it takes zero, one, or more inputs.
I love async but very rarely use await. It makes inversion of control patterns super easy and avoids deep logic and instead get something much more readable.
I treat await as a code smell and always triggers me to evaluate if we really need to be waiting for the result in this place. Most of the time they shoukd just return the promise or put something in a then.
People are going to misuse stuff but it doesn’t mean we shouldn’t use appropriate tools when appropriate.
EDIT: this is especially true for NodeJS where lots of frameworks are promise/async aware and support you returning a promise to them.
Async implicitly wraps the return in a promise if it otherwise wouldn’t return one. Useful for wrapping logic that otherwise would be synchronous. So, syntactic sugar so you don’t have to have “new Promise” to wrap what would otherwise be synchronous logic.
Instead of using await you can instead just use “.then(() => part that needs to wait)”, or a chain of “.then” on the returned promise to sequence dependent logic. Or if needing to wait on a set of async actions you have “Promise.all”. It is much more explicit on what part actually needs to wait instead of “everything after this in the function block”.
I prefer to just compose promises which allows you to sequence actions that need it. It is a code style preference but I find I end up with clearer codebases doing it this way.
Yes. Without using await, it's basically the same thing as just changing `return result` to `return Promise.resolve(result)`.
> Useful for wrapping logic that otherwise would be synchronous.
The logic is still synchronous, except now the return value is just wrapped in a promise.
> Instead of using await you can instead just use “.then(() => part that needs to wait)”
I don't understand why this would ever be desirable versus just calling the function synchronously. If for some reason you really need `.then` I would just wrap the call to the function, instead of making the fn async, `Promise.resolve(myFn()).then(() => part that needs to wait)`
> if needing to wait on a set of async actions you have “Promise.all”.
You can pass non-promise values to `Promise.all`, and it will work fine, although I don't see why you would do it intentionally. ie `await Promise.all([1, Promise.resolve(2)])// resolves to [1,2]`.
> It is much more explicit on what part actually needs to wait
If anything it's less explicit, you are disguising the true behavior. You making a synchronous function look like it's async when it isn't.
It's also going to suffer a small performance penalty, although it shouldn't really matter unless the function is used in some tight loop. When I tested calling a very simple `return 1` function, making it async resulted in the benchmark taking twice as long.
This is actually how rust handles async/await. If nothing is polling the future then the future is not running. If you want background execution like javascript then you need to hand it off to an executor (for example via `tokio::spawn`). Its actually pretty nice because then you can build a future and pass it around but you can decide if/when you want to execute it later.
That being said, you still wouldn't want to do a for loop awaiting each future.
I agree. People should gradually build up their intuition from lower abstractions to higher. People should be banned from using async/await unless they had first experienced callback-based code, and then promise-based code. Going straight to async code is like asking people to run before they have learned to walk.
They need to have experience and intuition working with promises without syntactic sugar, before being allowed to use syntactic sugar.
It's a basic way to learn. In Python you don't directly teach people about decorators without first asking them to explicitly reassign a function to the result of calling the decorator. In Haskell you don't teach people about do notation without first making them write nomadic code with the bind operator and many lambdas.
In many cases, just a few days of forbidding students to use the syntactic sugar is enough to make them appreciate why this syntactic sugar is needed and how it is supposed to be used. JavaScript's async/await is the same.
1. A terminal shouldn't be able to ask some resource on the internet what to type and auto-execute it.
2. AI fear/fatigue/???
I think point 1 is reasonable to an extent, but it should be taken in context. iTerm2 is a free app, and as far as I can tell, not even remotely required on any mac platform, since there is technically a default dumb terminal, which can be customized. I think the context issue is from the video demos I've seen, nothing directly types into your terminal, it's up to the user to review/copy/paste the generated code snippet. The underlying tech has been in iTerm for a while, from the best I can see. Auto-fill also enables things like the 1password integration, and anyone can open a chatgpt client and copy/paste shell code from there in the same way the iTerm2 integration works.
I understand point 2, I have never cared for any AI hype, it has near-zero interest for me, and doesn't affect my work. Almost every editor has some capacity to ask the internet for data and paste it in, from AI or otherwise, and no one is really sounding a major alarm bell around that. You could argue there is a big push for these integrations to train models, but even that requires a key.
The Bible. Even if you don't care for it's spiritual implications, there is a rich history that is used by archaeologists, and many face-value lessons of cause and effect, and even recommendations on how to manage a business and employees. The beautiful non-spiritual message is that humans don't change, but we can still learn from histories mistakes.
I feel like I've got to read it eventually just so I can be up to speed on all the millions of references to it in other works of art. In a college class recently, we read beowulf, and I was confused what was meant when grendel was described as being from "cain's clan" - I was raised non-religiously by parents who had both been burned pretty bad by institutional religion, so it was pretty much only me and an asian immigrant in that class who needed the reference explained. (Granted, I was one of the few non english majors in that class, which also probably affected my lack of understanding.)
The main cultural touchstones are disproportionately concentrated in a few books too, you can get a lot of them with just a dozen or two hours of reading.
Genesis specifically is packed with common references, can be read in a few hours, and is fairly engaging and accessible as a coherent piece of literature in its own right.
Ecclesiastes is like five pages and possibly the most quoted thing across european cultures. So many literary references and even common idioms come from there.
After that any one synoptic gospel + john + acts will set you up to catch a lot of christianity-specific cultural references. And then revelation imagery comes up a ton in pop culture, music, film & tv.
All of what I mentioned is about the length of a medium-short novel and would set you up to catch probably the majority of allusions to the bible. You'd be missing some major stuff like moses, david & solomon, plus a bunch of misc but influential stories like jonah & the whale, samson etc. But for bang for your buck it would get you pretty far.
Going through life without having read through at least some of the KJV Bible and Shakespeare would be like watching The Wizard of Oz in black and white – sure, you'd be able to follow the plot, but you'd be missing out on the color experience. Similarly, without having some foundation in those two foundational works of English language, you'd be missing idiom, metaphor, and allegory that you might not even realize is there. Imagine trying to read President Lincoln's speeches without getting his references to scripture. Imagine trying to read Faulkner's Sound and the Fury without getting the titular reference to Shakespeare and the structural reference to the Gospels (the same story told by four different authors).
If one is looking for a much more readable Bible, versus those low quality, thin paper, small typed copies, I'd recommend checking out Bibliotheca. Also has one of the best videos I've seen done for a Kickstarter campaign.
The single most significant fact supported by the Bible is the life, death, and resurrection of Jesus Christ. History agrees that Jesus was a real man. History agrees that He was significant in the region. The eye witness testimonies support (but don't prove) the resurrection, but consider this - many men and women were executed in the first century because they would not recant that they were eye witnesses to Jesus' crucifixion and resurrection. If it were a lie, why would so many take that to the point of their own death?
> If it were a lie, why would so many take that to the point of their own death?
Consider a weaker question: if it weren't a lie, why would so many take that to the point of their own death? While most people are usually opposed to lying, if they felt their reason for lying was important enough - and if they're willing to die for it then it must be - they could easily overcome that.
I would argue that the average person would lie to preserve their life. Not all, of course, that's a pretty wide stroke to paint many people with.
The resurrection of Jesus Christ is a dividing point to all humanity, and there are many willing to die on either side of the fence. While it has been contested many times, there is no definitive proof that Jesus was not resurrected, and there is pretty solid evidence that Jesus did die on the cross (as opposed to old age or some other natural cause). We also know that the Jewish leaders at the time of Jesus were furious at Christianity, and had a serious campaign to destroy and discredit it, yet it survived. You'd think that with their financial and people resources, they could have recovered a body or exposed Jesus as a fraud.
Christianity is Jesus Christ substitutes the sin of a faithful man or woman with His righteousness.
You cannot buy faithfulness, and you cannot obtain righteousness through good works on your own.
The target has never been against wealth, but the love of money, or trusting in the things of this lifetime. For instance, Proverbs 11:28 says not to trust in wealth. Mark 8:36, Jesus states that if you seek wealth over everything else, what good is it when you die? In 1 Timothy 6:17-19, Paul encourages Timothy in his leadership to instruct wealthy people to not put their hope in their wealthy, but to do good with what God has given them.