Perhaps at that point we're better off settling on a way to pass components through as parameters? <!-- App.html --> <Outer contents={Inner}/> <!-- Outer.html --> <div> <div>Something</div> <[contents] foo='bar'/> </div>

I would hope for it to come with React-like behavior where I could pass in a string (like div or a) and have it show up as a normal div/a element when the child component used it.

I'll work on a preliminary PR (which I expect will need some love from maintainers, sorry!)

The lack of spread continues to be a big pain for me, adding lots of difficult-to-maintain cruft in my components. Having to maintain a list of all possible attributes that I might ever need to pass through a component is causing me a lot of friction in my most composable components.

Use case: Wrapper components that need to render an element (e.g. because they attach event listeners). You'd probably use a <div> there by default but there may be places where this is not desirable for semantic reasons (e.g. in lists).

const components = { Label, Tree, Menu };

To me, abandoning all these live upgrades to have only k8s is like someone is asking me to just get rid of all error and exceptions handling and reboot the computer each time a small thing goes wrong.

Références1°'degré:art.1°',2et3del'arrêtédu13mai1985relatifauconseild'école,circulairen°2000-082du9juin2000relativeauxmodalitésd'électiondesreprésentantsdesparentsd'élèvesauconseild'école.2"°'degré:art.R.421-26,R.421-29etR.421-30ducodedel'éducation.

L'articleL.1'|'I-4ducodedel'éducationdisposequelesparentsd'élèvesparticipent,parleursreprésentants,auxconseilsd'écoleetauxconseilsd'administrationdesétablissementsscolairesetauxconseilsdeclasse

Critical Code Studies Working Groups (CCSWGs)

Code is a social text, the meaning of which develops and transforms as additional readers encoun-ter it over time and as contexts change

I'm more likely to use it than alternatives in future projects - it's simple and clean

and making the code more beautiful and compact and human readable

There’s a bunch of fiddly syntax here, not to mention 2 separate build stacks and 3 sets of dependencies, but the end result is awesome. Simply renaming a field on a shared model will reveal all the React components using that value on the front-end, and back-end code using it.

The “shared” schema is effectively the API schema. These are the fields exchanged in the API, common to client and server.

À cette fin, comme le prévoit l'article D. 111-8 du Code de l'éducation, les directeurs d'école et les chefs d'établissement doivent communiquer aux associations de parents d'élèves qui en font la demande la liste des parents d'élèves de l'école ou de l'établissement scolaire mentionnant leurs noms, adresses postale et électronique, à la condition que ceux-ci aient donné leur accord exprès à cette communication.

there is one major weakness to this approach and to scoped CSS: organization gets very hard – you end up with styles everywhere!

Keeping the CSS with the HTML for organization may have value however.

Because of that, it's easy to end up in a situation where the styles for a given piece of markup are defined far away (in terms of number of lines) from the markup itself, which reduces the advantage of having styles and markup co-located in the first place.

One of the arguments that's frequently deployed in favour of JSX-based frameworks over template-based ones is that JSX allows you to use existing language constructs:

but adding logic to the <script> is unfortunate

async function onEdit() { editing = true // enter editing mode await tick() nameEl.focus() }

It’s harder to read code than to write it

It’s 2020, doesn’t everyone use VSCode already?

“I came to Rust from Haskell, and I feel that Haskell is a very elegant and safe language. The biggest differentiator for me is that there is a greater difference between high-performance code and idiomatic ‘clean’ code in Haskell than in Rust. Most Rust code looks like most other Rust code, even when it performs well. Haskell can become unfamiliar real quick if someone is operating under different libraries and goals from what you are typically doing. Small differences in syntax can result in huge differences in behavior, and Rust has more uniformity on that axis.”

The key to successfully creating reusable components using both render props and scoped slots is being able to correctly separate behavior from presentation. Each time you create a new UI component, think “What is the core behavior of this component? Can I use this anywhere else?”

In your environment you may want to always configure internationalization, routers, user data etc. If you have many different React roots it can be a pain to set up configuration nodes all over the place. By creating your own wrapper you can unify that configuration into one place.

prevent its disclosure to any person not authorized to create the subscriber's digital signature

Acknowledgments

Build cross-platform, native iOS and Android apps without web views. Get truly native UI and performance while sharing skills and code with the web

Garantir le respect des droits de l’enfant Recommandation 2Le Défenseur des droits recommande l’inscription, dans le code de l’éducation et le code de l’action sociale et des familles, de l’interdiction de tout châtiment corporel ou traitement humiliant à l’égard des enfants

clean and understandable markup template without the help of 3rd party

I was just expressing that, even thought I like React, I dread having to still manually handle everything, instead of just using a directive, a la Vue.JS. This is what I consider boilerplate. Hence my comment on how I could leave React for Svelte just because of that. Clearly a Svelte side-by-side code comparison shows a much cleaner code for Svelte.

I really do not like writing templates in a file, such as #each , #if. I do not like to prefer using new approaches for which i can do it with purely in JavaScript.

Aujourd’hui, pour les seuls code pénal et code du travail, on atteint en France 25 critères21, et jusqu’à 30 si l’on considère d’autres codes (code de l’assurance maladie, de l’éducation...)

This is the first post of the Disassembling Rails series. What I want to do is to give you a general idea about how Rails' components interact with each other when you use its functionalities (like fragment caching).

l’article L. 241-4 du code de l’éducation prévoit que « l’inspection des établissements d’enseignement privés porte sur la moralité, l’hygiène, la salubrité (…)

export DOCKER_TLS_VERIFY=1 export DOCKER_CERT_PATH="$DOCKER_TLS_CERTDIR/client"

if [ -z "${DOCKER_HOST:-}" ]; then if _should_tls || [ -n "${DOCKER_TLS_VERIFY:-}" ]; then export DOCKER_HOST='tcp://docker:2376' else export DOCKER_HOST='tcp://docker:2375' fi fi

if [ -n "${DOCKER_HOST:-}" ] && _should_tls; then export DOCKER_TLS_VERIFY=1 export DOCKER_CERT_PATH="$DOCKER_TLS_CERTDIR/client" fi

if [ -z "${DOCKER_HOST:-}" ] && [ ! -S /var/run/docker.sock ]; then if _should_tls || [ -n "${DOCKER_TLS_VERIFY:-}" ]; then export DOCKER_HOST='tcp://docker:2376' else export DOCKER_HOST='tcp://docker:2375' fi fi

There are no plans to deprecate the REST API. To reduce the technical burden of supporting two APIs in parallel, they should share implementations as much as possible.

Have adopted CI best practices and are defining their CI/CD pipelines as code

Docker 19.03 does this automatically # by setting the DOCKER_HOST in # https://github.com/docker-library/docker/blob/d45051476babc297257df490d22cbd806f1b11e4/19.03/docker-entrypoint.sh#L23-L29

Rule of Generation: Avoid hand-hacking; write programs to write programs when you can.

REM This file was produced by typing in a listing from appendix B of Hugh Burns' thesis,

We have come to a place where thanks to many libraries and frameworks, and overall improving software, what would’ve once used many developers to build from scratch is now more often than not, a bunch of people plumbing different things together. Software is creating software faster than we can use it. This is also why you are seeing so many of these “no-code” or “low-code” solutions pop up all over the place. There are increasingly fewer reasons to write code, and those who are writing code should, and do, increasingly write less of it. This will only be more accelerated by shifting to remote work due to how it’s going to change how we decide what code to write.

Anyone who’s spent a few months at a sizable tech company can tell you that a lot of software seems to exist primarily because companies have hired people to write and maintain them. In some ways, the software serves not the business, but the people who have written it, and then those who need to maintain it. This is stupid, but also very, very true.

Jones did make one change, adding a question that asked students to reflect on their experience during the pandemic, and how it will shape their approach to studying family history.

Code Owners allows for a version controlled single source of truth file outlining the exact GitLab users or groups that own certain files or paths in a repository.

It should be possible to implement the functionality of page-translator via a more popular extension that is designed to inject arbitrary data into websites, including remote code, e.g. https://addons.mozilla.org/en-US/firefox/addon/greasemonkey/ .

Add-ons are not allowed to contain obfuscated code, nor code that hides the purpose of the functionality involved. If external resources are used in combination with add-on code, the functionality of the code must not be obscured.

Mozilla can still block distribution of the extension, even when not distributed via ADO. It is not possible for us to provide Mozilla the unminified JavaScript source files for Google’s and Microsoft’s translation widgets. This is a risk because Mozilla can demand such.

Mozilla does not permit extensions distributed through https://addons.mozilla.org/ to load external scripts. Mozilla does allow extensions to be externally distributed, but https://addons.mozilla.org/ is how most people discover extensions. The are still concerns: Google and Microsoft do not grant permission for others to distribute their "widget" scripts. Google's and Microsoft's "widget" scripts are minified. This prevents Mozilla's reviewers from being able to easily evaluate the code that is being distributed. Mozilla can reject an extension for this. Even if an extension author self-distributes, Mozilla can request the source code for the extension and halt its distribution for the same reason.

the Indian Word Code used here: https://archive.org/details/in.ernet.dli.2015.108786

“The source code for Falcon is so good, I almost prefer it to documentation. It basically can’t be wrong.”

n the near future, given the increase in the use and profile of preprintservers, and alternative publishing platforms such as F1000 Researc

find src -name '*.js' -print | xargs jscodeshift -t node_modules/@material-ui/codemod/lib/v4.0.0/top-level-imports.js

source

From error.c