Templates with logic versus "logic-less" templates is a hotly debated point among template language designer and users. Dust straddles the divide by adopting a "less logic" stance.

Obviously we shouldn't rush into anything. But changes like these are best made earlier on in a project's lifecycle, so I'm eager to hear what people think so that we can start making some progress.

The success of JSX has proved that the second curly is unnecessary. Moreover, a lot of people — particularly those who have been exposed to React — have a visceral negative reaction to double curlies, many of them assuming that it brings with it all the limitations of crusty old languages like Mustache and Handlebars, where you can't use arbitrary JavaScript in expressions.

please direct questions like yours to the proper channels, i.e. the systemd mailing list. Random github issues are really not the place to ask such questions.

Well, at the risk of making things too easy...

with a minimum of scary brackets

Please don't copy answers to multiple questions; this is the same as your answer to a similar question

You may want to execute validations in a given specific order (this can be tricky especially when you have got asynchronous validations).

If you want to implement a form with a superb User Experience, you have to take care of many variables:

Library author here. I'm always fascinated by new ways people can invalidate my assumptions. I mean that in a sincerely positive way, as it results in learning.

I too have been confused by behavior like this. Perhaps a clearly defined way to isolate atomic units with synchronous reactivity would help those of us still working through the idiosyncrasies of reactivity.

Yeah I see what you're saying. In my case, I had a group of classes that relied on each other but they were all part of one conceptual "module" so I made a new file that imports and exposes all of them. In that new file I put the imports in the right order and made sure no code accesses the classes except through the new interface.

manually specifying the order isn't really a great solution (as tempting as it sounds) because you'll probably have broken behaviour if you subsequently move away from Rollup.

Doing so also means adding empty import statements to guarantee correct order of evaluation of modules (in ES modules, evaluation order is determined statically by the order of import declarations, whereas in CommonJS – and environments that simulate CommonJS by shipping a module loader, i.e. Browserify and Webpack – evaluation order is determined at runtime by the order in which require statements are encountered).

Specifically, since Root, Rule and AtRule all extend Container, it's essential that Container is evaluated (and therefore, in the context of a Rollup bundle, included) first. In order to do this, input.js (which is the 'gateway' to all the PostCSS stuff) must import root.js, root.js must import rule.js before it imports container.js, and rule.js must import at-rule.js before it imports container.js. Having those imports ensures that container.js doesn't then try to place Root, Rule or AtRule ahead of itself in the bundle.

Replaced nested `require` statements with `import` declarations for the sake of a leaner bundle. This entails adding empty imports to three files to guarantee correct ordering – see https://github.com/styled-components/styled-components/pull/100

Modules from the following layer can require anything from all the previous layers, but not vice versa.

You can imagine how big of a surprise was finding out that model/character being a child of model/node causes an error when we import model/position.

Many black business owners blamed the problem on lowerclass peoples’ affliction with the “white man’s psychology,” namely, that migrantshad been brainwashed into thinking they had to shop in a white-owned store, eitherbecause whites would punish them if they didn’t or because white stores were nec-essarily higher quality than black ones.48Whether this was the case or not, therewere several other things complicating black consumers’ willingness to shop inblack-owned businesses.

Accordingly, our results strongly suggest thatonlineinstructionin keyintroductorycollege-level courses, at least as currently practiced, maynot be aseffectiveasface-to-faceinstructionat2-yearcommunitycolleges.

that will advance justice and opportunity for college athletes. The proposal will guarantee fair and equitable compensation, enforceable health and safety standards, and improved educational opportunities for all college athletes.

Note that the <WarningEngine/> component must be at the bottom of the form to guarantee that all the fields have registered.

Higher education institutions need to address these challenges, and technological tools — even some surprisingly simple ones — can go a long way toward enhancing the college experience for older students, says Brian Fleming, executive director of the Sandbox ColLABorative at Southern New Hampshire University.

While our program still faces some challenges around engaging our students and keeping them enrolled in programs long enough to complete their goals, technology has allowed us to make some remarkable strides.

Online learning environments have a promising future for researchers, practitioners, and learners. However designing and developing more effective and efficient online learning environments is possible with ongoing research and development. This paper offers four research goals and matches four existing methodologies to improve student outcomes in online learning environments defined as learner achievement, engagement, and retention.

Technology integration has also been shown to help create more authentic learning environments where the students are more motivated to attend, have a greater chance of communication and collaboration and have more opportunities to use higher order thinking and problem solving skills connected to real world applications (Fouts, 2000) This has led some to believe that new theories in learning needed to be developed that would help to support the creation of such learning environments. The three emerging theories discussed in this paper all possess the ability to support the creation of such learning environments.  They all support the idea that learning is through action.  They all support that cognition happens through communication and collaboration with others.  They all support the use of technology to help in the creation of such learning environments. It is through these new theories that learning environments, which support the development of these higher-level learning skills, can be created.  

Research about adults as learners can inform the design of effective digital learning experiences. Although there is no one principle that can be applied to all adults, the design principles outlined here are based on five of the prevailing theories about how adults learn: andragogy, experiential learning, self-directed learning, transformational learning, and neuroscience.

Faculty need to focus on learning theory in the design of instructional technology so that they can create lessons that are not only technology-effective but that are meaningful from the learner’s standpoint.

Type safety. Entire codebase is written in TypeScript.

just saying that if you're going to try to go with a markup approach, at least go all the way, instead of the frankenstein that is JSX

I'm okay with an overall design that allows people to plugin the parts they need in order to be able to generically support a compile-to-javascript language, but to bake in support for one singular solution because its popular is simply bad engineering.

One of the primary tasks of engineers is to minimize complexity. JSX changes such a fundamental part (syntax and semantics of the language) that the complexity bubbles up to everything it touches. Pretty much every pipeline tool I've had to work with has become far more complex than necessary because of JSX. It affects AST parsers, it affects linters, it affects code coverage, it affects build systems. That tons and tons of additional code that I now need to wade through and mentally parse and ignore whenever I need to debug or want to contribute to a library that adds JSX support.

Yes, you can embed loops in it and compose lots of small repeated JSX snippets, but that almost never happens in practice because mixing the turing complete of javascript with the markup of HTML eliminates the readability of JSX so that it is actually harder to parse than a solution like hyperscript (the syntactical approach taken by virtual-dom).

The react community has become a big cargo cult. There are some good ideas in the community and many Bad Ideas™. Paving the bad idea cowpaths lends a sense of legitimacy to these bad technical ideas that is not merited.

This is the problem with baking in support for frameworks with special cases in the codebase. You can never support all the frameworks. :-(

The problem is that not all tooling supports adding new dependencies from a transform. The first step is figuring out how this can be done idiomatically in the current ecosystem.

It's much easier to iterate on new versions by deploying npm packages than updates to the compiler toolchain. Therefore, it might be best if the actual implementation still lives in the react package.

Incurring high-cost changes isn't evolutionary design-it's oscillation caused by poor planning and requirements specification on a high cost-of-change component-it tips the anticipation/adaptation balance too far towards adaptation.

That is, we envision a cuisine and an attendant lifestyle that is more au-thentic and less stressful, more "natural," than the world in which we live.

Moreover, React team even removed the “highlight updates” feature from dev tools because people used to obsessively haunt wasted renders with no reasoning behind it

More in-depth examples definitely sound like a good idea. I've seen cookbooks quite a few times already and they are always helpful.

Built with remark

Built on remark

It’s what powers remark (Markdown), retext (natural language), and rehype (HTML), and allows for processing between formats.

Arguably, it leans into JSX land—including logic in the templates.

I could imagine people putting a more complex expression in an @const than we typically find in svelte expressions today, which might create more demand for those blocks to have TypeScript support, which I don't think they have now.

About the argument against it, "{@const will make code less consistent ": I think the same is true now, since people can come up with very different ways of dealing with the "computed value inside each loop/if function" problem. Some extract components, some use functions, some will prepare the array differently beforehand.

Also a vote against, for the simple reason that logicless templates would be the ultimate goal for me.

one of the reasons people sometimes balk at mustache-like syntax is just that: logic in the templates.

it also allows for more divergence in how people write there code and where they put their logic, making different svelte codebases potentially even more different due to fewer constraints. This last point is actually something I really value, I read a lot of Svelte code by a lot of different people and broadly speaking things look the same and are in the same places.

IMO svelte does have a responsibility to teach/demo the basics of "functional javascript" probably as a docs/tutorial/demos chapter on "the power of javascript expressions"

Every new variation to the view requires updating both the view model and the template. This holds true even for simple variations.

Writing a logic-less template requires a bloated view model with comprehensive getters for the raw data. As a result, a messy and difficult-to-maintain view model usually accompanies logic-less templates.

Full-of-logic, logic-less, and less-logic solutions

that does not mean that I am advocating the other extreme–i.e., a templating language that allows a lot of logic. I find such templating languages, especially those that allow the host programming languages to be used inside the template, to be hard to read, hard to maintain, and simply a bad choice.

Mustache is described as a "logic-less" system because it lacks any explicit control flow statements, like if and else conditionals or for loops

Here, when x is a Boolean value then the section tag acts like an if conditional, but when x is an array then it acts like a foreach loop.

Our custom useEffect is not idiomatic Svelte.

We want to improve this while keeping both the API and the semantics and behavior as Reactish as possible.

For reasons of compatibility and simplicity, it's best to use React's built-in state management capabilities rather than external global state.

It provides several capabilities that are difficult to achieve with React alone, while being compatible with the newest features of React.

I’d still be interested in Svelte making things easier so I’ve opened a feature request for Reactive statement cleanup functions.

Svelte doesn't re-render, so you need to respond to component mount/dismount and prop changes separately as they are distinct concepts and never tied together, unlike in React.

Sometimes, you may be tempted to write that wrapper. Because all your (React or Vue or insert your reactive framework here) instincts tell you so.Resist the temptation. There is a better way. A svelter way. Introducing: the use-directive (a.k.a. “actions”).

However, especially when starting out, it’s very easy to fall into the “this is how I did things in my previous framework” trap.

It's sort of unfortunate that the justification for existence comes from pointing at gaps.

It was clear no one was interested in what I was working towards.

Although I also work with solid in my day job at inrupt, I wrote this guide in my spare time.

Built on TypeScript.

There's one downside to Reacts reactivity model - the hooks (useState and useEffect) have to always be called in the same order and you can't put them inside an if block.

createState and createSignal are improvements over React's useState as it doesn't depend on the order of calls.

import page from "//unpkg.com/page/page.mjs";

Or with modules, in modern browsers

this is a common Svelte idiom for manually invalidating something that might have been mutated without there being a visible = sign somewhere

Because I haven't worked with React Native, and so I'm not a specialist in it, and developing a React Native version of this package would better be done by someone being an expert in React Native.

Graeber has a great deal more to say about money and its unique capacityto store value, and also about the ideology of the market with its highlyindividuated notion of human desires (e.g. 2001: 257). His analysis opensup an intriguing question. If in market societies money is a measure, amedium and above all an end in itself (2001: 66) and value-for-moneydominates what we conventionally call the economy, how do other valuescoexist with this monetarized realm and its rationality of quantificationand self-interest? Graeber points out that, in our view of society, marketprinciples can be balanced by family values and altruistic charity (2001:257), but he views these as just ‘two sides of the same false coin’

Only peer dependencies: Svelte and Final Form

t’s not clear why the sequence of the vaccines only mattered in girls, partly because there has been very little research into how male and female immune systems are different. “Somehow immunology has been blind to sex,” says Aaby. “If you read research about mortality in low income countries, there is no such thing as boys and girls – there are children. So we perceive that they have to be the same, and they are definitely not the same.”

It depends - do you accept the new code of conduct? :P

But maybe this PR should still be merged until he finds time for that?

let:hovering={active}

let:active={hovering}

As you can see, it uses Javascript label syntax to tell the compiler where recalculation should be carefully managed. And you thought that no one uses labels any more.

It ends with love, exchange, fellowship

The benefit of this approach is that rather than having these defaults and fighting against them, it’s fully up to you to decide how to handle everything.

So I guess what @Rich-Harris is trying to say is that (sorry, I'm just logging it here for my own benefit)

Basically, the idea is that a train tried to start with the caboose brakes stuck on. After releasing the caboose, the train still could not start. The problem was that when the train attempted to start with the caboose brake on, it stretched all the inter-car couplings so that the whole train was just like one big car. At this point, the friction from the engine train wheels was not enough to get the whole thing going. Instead, you need to just get one car moving at a time - this is why there is space between the couplings.

GitHub issues aren't the right place for support questions like this. Please ask on StackOverflow or in our Discord chat room.

I don't understand why it just launches the mutation once and then it throws the error Function called outside component initialization, the only way to make it work is to do something like $: result = mutation(...) but it doesn't make sense, I don't want to run the mutation after each keystroke.

We’re still working on idiomatic Svelte APIs so this one’s also on our list to figure out what the best way forward is

answered

I think Svelte's approach where it replaces component instances with the component markup is vastly superior to Angular and the other frameworks. It gives the developer more control over what the DOM structure looks like at runtime—which means better performance and fewer CSS headaches, and also allows the developer to create very powerful recursive components.

and one which you don’t need to use and won’t add any code to your app if you choose not to use

And of course, if you don't use them you don't pay for them

I was… not one of those assigned to watch our chosen one, so I can’t say much about exactly what happened within the walls of that house, but it seems the fight scarred the place in a way far deeper than simple fire. A scar in reality, that I believe has since been compounded by the interferences of other powers.

Regardless, the effect it had on Agnes was unanticipated. As far as we could tell, she had destroyed the place utterly. And yet she remained bound to it, tied to it in some vital way. I knew when Arthur told me she had kept Raymond Fielding’s hand, that he was worried. But none of us could know what you were going to do.

I was now about to form another being of whose dispositions I was alike ignorant; she might become ten thousand times more malignant than her mate and delight, for its own sake, in murder and wretchedness.

Eliminating needless classes frees up operating memory on the computer—and bandwidth in your head.

I understand what you're getting at, but we shouldn't miss out on useful features just because a few developers will abuse it...

Your styles are scoped to the component. No more leakage, no more unpredictable cascade.

It's fashionable to dislike CSS. There are lots of reasons why that's the case, but it boils down to this: CSS is unpredictable. If you've never had the experience of tweaking a style rule and accidentally breaking some layout that you thought was completely unrelated — usually when you're trying to ship — then you're either new at this or you're a much better programmer than the rest of us.

It gets worse when you're working on a team. No-one dares touch styles authored by someone else, because it's often unclear what they're doing, what markup they apply to, and what disasters will unfold if you remove them. The consequence of all this is the append-only stylesheet. There's no way of knowing which code can safely be removed, so it's common to undo some existing style with another, more specific style — even on relatively small projects.

The old mydata and the new mydata are actually the same physical object (only the object’s internal value changed)

When the woman saw that the fruit of the tree was good for food and pleasing to the eye, and also desirable(AT) for gaining wisdom, she took some and ate it.

TypeScript provides a language service which can do all the heavy lifting for us

Considerable research indicates that college students are bothmore likely to persist and to perform at high academic levelswhen they perceive themselves to be members of a cooperativeand supportive learning community (Kuh, 2009; Tinto, 2006;Zhao & Ku, 2004)

This giant machine can be your best friend as long as you’re good for the business. But if you accidentally happen to get in its way, it’ll simply screw you over and won’t even notice. If tomorrow a corporate lawyer decides they need to cover their corporate ass more tightly — be it international sanctions, dodging any potential lawsuits from vocal minorities, or anything else — they won’t think twice: they’ll readily dispose of anyone and betray any “ideals” you might have thought they stand for.

many organizations have been burned by the high churn in JavaScript tooling, which sadly moves projects backwards as a part of moving the web forward

A final strand of the development of the prosperity gospel was the development of charismatic Pentecostal churches in America. An umbrella term for a decentralized group of churches — comprising over 700 denominations — Pentecostal churches are characterized by an emphasis on what is known as “spiritual gifts” (or charisms, from which the term “charismatic” is drawn). A worshipful Christian might experience, for example, the gift of healing, or might suddenly start speaking “in tongues.” This tradition of worship meant that, for a believer, the idea that God would manifest Himself to the faithful in concrete, miraculous ways in the here and now was more prevalent than it would be in, say, a mainline Episcopalian church. In addition, the decentralized nature of these churches also meant that individual leaders, many of whom practiced faith healing or similar practices, had a particularly strong effect on their congregations and could build up individual personal followings.

Using awesome Ant Design as UI framework