I highly recommend setting a higher bound on the number of returned entities by each resolve function in your code.

withindex.js, we have a single source of truth, giving fine grained control on what we expose to the outside world.

The index.js file is the main entry point and imports and exports everything from internal.js that you want to expose to the outside world.

This does solve the problem, but now our project and API is structured differently. In large projects it might be very hard to determine how to pull this trick off, or even impossible!

In a large code base, this will result in moving imports randomly around until stuff just happens to work. Which is often only temporary, as a small refactoring or change in import statements in the future can subtly adjust the module loading order, reintroducing the problem.

To silence circular dependencies warnings for let's say moment library use: // rollup.config.js import path from 'path' const onwarn = warning => { // Silence circular dependency warning for moment package if ( warning.code === 'CIRCULAR_DEPENDENCY' && !warning.importer.indexOf(path.normalize('node_modules/moment/src/lib/')) ) { return } console.warn(`(!) ${warning.message}`) }

Any software that makes HTTP requests to other sites should make it straightforward to enable the use of a cache.

Take responsibility for your outgoing network traffic If you install software that interacts with other sites over the network, you should be aware how it works and what kind of traffic it generates. If it has the potential to make thousands of requests to other sites, make sure it uses an HTTP cache to prevent inflicting abuse on other sites.

Identify your user agents When deploying software that makes requests to other sites, you should set a custom User-Agent header to identify the software and provide a means to contact its maintainers. Many of the automated requests we receive have generic user-agent headers such as Java/1.6.0 or Python-urllib/2.1 which provide no information on the actual software responsible for making the requests.

It is not appropriate to use these document types for live content. These are made available only for download, to support local use in development, evaluation, and validation tools. Using these versions directly from the W3C server could cause automatic blockage, preventing them from loading. If it is necessary to use schemata in content, follow guidelines to avoid excessive DTD traffic. For instance, use caching proxies to avoid fetching the schema each time it is used, or ensure software uses a local cache, such as with XML catalogs.

A simple rule of thumb: the name of the updated variable must appear on the left hand side of the assignment. For example this... const foo = obj.foo; foo.bar = 'baz';...won't update references to obj.foo.bar, unless you follow it up with obj = obj.

Longstanding controversy surrounds the meaning of the term "hacker". In this controversy, computer programmers reclaim the term hacker, arguing that it refers simply to someone with an advanced understanding of computers and computer networks[5] and that cracker is the more appropriate term for those who break into computers, whether computer criminals (black hats) or computer security experts (white hats).

One of Svelte's advantages, for me, is that I can test out ideas with relatively few lines of code. the #with feature could save me from adding a separate component for the content of an #each loop. I get frustrated when I have to create a new file, move the content of the #each clause, import it as a component, and add attributes and create exports for that, and implement events to send messages back, and event handlers, when I just wanted to test a small feature.

Wondering how to get field state from multiple fields at once? People coming from Redux-Form might be wondering where the equivalent of Redux Form's Fields component is, as a way to get state from several fields at once. The answer is that it's not included in the library because it's so easy to write one recursively composing Field components together.

One of the significant differences between the two is that a call to a partially applied function returns the result right away, not another function down the currying chain; this distinction can be illustrated clearly for functions whose arity is greater than two.

Looks like the problem is that debounce defaults to waiting for 0 ms ... which is completely useless!

It looks like you accidentally passed resolve() (immediately invoking the function) directly to setTimeout rather than passing a function to invoke it. So it was being resolved immediately instead of after a 1000 ms delay as intended.

You should not create a new debounce function on every render with: return new Promise(resolve => { debounce(() => resolve(this.getIsNameUnique(name)), 2000); }); Instead you should just wrap your whole function isNameUnique with the debounce (see my sandbox). By creating a new debounce function on every hit, it cannot 'remember' that is was called or that is will be called again. This will prevent the debouncing.

_.debounce creates a function that debounces the function that's passed into it. What your s.search function is doing is calling _.debounce all over again every time s.search is called. This creates a whole new function every time, so there's nothing to debounce.

I run s.search() by typing into an input box, and if I type gibberish very quickly, the console prints out "making search request" on every key press, so many times per second -- indicating that it hasn't been debounced at all.

they're not invoking the function that _.debounce returns

If you define a variable outside of your form, you can then set the value of that variable to the handleSubmit function that 🏁 React Final Form gives you, and then you can call that function from outside of the form.

Also, if you don't put that implementation of URLSearchParams in the global scope you're not using it as a polyfill but a ponyfill, and those are meant for your code, not for external dependencies.

Sometimes we can’t implement a solution that’s fully spec-compliant, and in those cases using a polyfill might be the wrong answer. A polyfill would translate into telling the rest of the codebase that it’s okay to use the feature, that it’ll work just like in modern browsers, but it might not in edge cases.

Use ponyfill.com for linking here.

"doesn't work" is meaningless

Using the keyboard arrows, navigate down the suggestion list to the item(s) you want to remove from the Chrome autofill suggestions With the suggestion highlighted, use the appropriate keystroke sequence to delete the Chrome suggestion:

FI:

Once again, this isn’t good or bad, it’s just the most efficient way to create something that is similar to something else

This isn’t to say that multiplying code is good or bad – it’s a characteristic of all code regardless of quality.

Anyone who’s ever worked with me knows that I place a very high value on what ends up checked-in to a source code repository.

The reason for this is very simple: once code gets checked-in, it takes on a life of its own.

Checking in is akin to sharing your code with others, and once out in the world, it’s hard to predict what that code will do.

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.

Of all the compile-to-languages, the one that strikes me as having the least merit is JSX. It's basically a ton of added complexity for the sake of what boils down to syntax. There are no real gains in terms of language semantics in JSX.

Furthermore, JSX encourages bad non-dry code. Having seen a lot of JSX over the past few months, its encourages copypasta coding.

I know where you're coming from, and to a degree, I think you're right.

If the react cargo cult didn't have the JSX cowpath paved for them and acclimated to describing their app interface with vanilla javascript, they'd cargo cult around that. It's really about the path of least resistance and familiarity.

hyperscript is much simpler to refactor and DRY up your code than with JSX, because, being vanilla javascript, its easier to work with variable assignment, loops and conditionals.

The only "issue" it has is that its unfamiliar. People have been working with HTML for years and are comfortable with it. That's basically the only reason that people find it more readable. If you make an effort to spend sometime with hyperscript, it becomes as familiar and readable as jsx.

However, as a developer that uses JSX, I find it too useful/concise to give up in the name of syntax purity, especially when I know that what it translates to is still very isolated and computationally pure.

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

I've recently started playing with segmentio/deku, an alternative to React, and I'm also using Babel to transpile my js and jsx code.

The reason why we don't just create a real DOM tree is that creating DOM nodes and reading the node properties is an expensive operation which is what we are trying to avoid.

This module is similar to JSX, but provided as a standards-compliant ES6 tagged template string function.

if you think this project can help you or anyone else, you may star it on GitHub

For the sake of best compatibility we convert the className attribute to class for svelte.

For event listeners we support the standard jsx naming convention onEventname (this is converted to on:eventname in svelte) as well.

We aim to support all svelte features. In some cases this is not possible. For those cases we provided feasible workarounds.

jsx currently does not allow to use : in attribute/property names. As a workaround every : can be replaced be _ (for example bind_value is converted to bind:value for svelte).

The goal is to bring element creation down to this logic:

In React 0.12 time frame we did a bunch of small changes to how key, ref and defaultProps works. Particularly, they get resolved early on in the React.createElement(...) call. This made sense when everything was classes, but since then, we've introduced function components. Hooks have also make function components more prevalent. It might be time to reevaluate some of those designs to simplify things (at least for function components).

However, in function components there really isn't much need for this pattern since you can just use JS default arguments

Right, and if most uses of an FTP service use new FtpService() the one that sets an alternate port will stand out (service.SetPort(12345))

Good risk management is inherently simple; adding too many complexities increases the likelihood of overlooking the obvious.

I recommend folks use https://github.com/shama/bel instead of this package; we've been working hard on it for the past two years to make sure it has all the features you could want to write inline HTML. Hope it's good; closing for now!

By default all content inside template strings is escaped. This is great for strings, but not ideal if you want to insert HTML that's been returned from another function (for example: a markdown renderer). Use nanohtml/raw for to interpolate HTML directly.

Hyperscript syntax for React.js markup

However, this would lead to further divergence. Tooling that is built around the assumptions imposed by template literals wouldn't work. It would undermine the meaning of template literals. It would be necessary to define how JSX behaves within the rest of the ECMAScript grammar within the template literal anyway.

Deku is a library for rendering interfaces using pure functions and virtual DOM.

It also aims to support only modern browsers to keep things simple.

One of the inherent dangers of any form of iterative development is confusing iteration with oscillation.

However, know when to be inconsistent -- sometimes style guide recommendations just aren't applicable.

When applying the guideline would make the code less readable, even for someone who is used to reading code that follows this PEP.

although this is also an opportunity to clean up someone else's mess

To be consistent with surrounding code that also breaks it (maybe for historic reasons)

An onevent event handler property serves as a placeholder of sorts, to which a single event handler can be assigned. In order to allow multiple handlers to be installed for the same event on a given object, you can call its addEventListener() method, which manages a list of handlers for the given event on the object.

Then at some moment I just stumbled upon limitations and inexpressiveness of templates and started to use JSX everywhere — and because JSX was not a typical thing for Vue I switched to React over time. I don’t want to make a step back.

But the vast majority of things that our apps are doing are just conditional and list rendering.

In my opinion it is okay to say your tool is revolutionary compared to existing ones. And it is hard to be fully unbiased about your own creation, I get it.

Tables are not yet supported. If you love impossible to read regular expressions, submit a PR!

I suppose it all comes down to tooling. It should be easy to author a pattern. A set of implicit (possibly explicit) patterns to author patterns may be useful.

Thank you to those who have failed many times, yet never gave up

A reasonably clean alternative would be to map a function over the array and use destructuring in the each loop: {#each [1, 2, 3, 4].map(n => ({ n, sqr_n: n * n })) as { n, sqr_n }} {sqr_n} {sqr_n / 2}<br> {/each}

I discovered that a solution can be hacked using an {#if}, but a proper one would be nice:

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

Offsetting the rules of a logic-less template requires a lot of helper methods.

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.

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.

It's certainly something I've wanted to reach for prior

An alternative (maybe not good) would be to restrict {@const} to certain blocks like {#each} and {#if}. In both cases, it significantly reduces the "multiple ways to do the same thing" problem and avoids ergonomic and performance overhead of our current situation.

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.

I had this problem and figured out how to make something like this work with the compiler quirks.

Here's a proxy store I wrote to derive the value of a store nested within other stores, it plays nice with typescript and can go infinitely deep

Generally, you should read the value of a store by subscribing to it and using the value as it changes over time. Occasionally, you may need to retrieve the value of a store to which you're not subscribed. get allows you to do so.

This reactive statement is just used to have the store automatically subscribed and unsubscribed.

I'm not sure I understand the problem, everything you are describing is already possible.

Svelte right now has a lot of opportunities to have component state become out of sync with props.

I'm suggesting this is a problem generally. Users will not think of being out of sync with props

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.

the code is a bit verbose/convoluted

To fix our Svelte version you might think we could use beforeUpdate or afterUpdate, but these lifecycle functions are related to the DOM being updated, not to prop updates. We only want to rerun our fetching when the album prop is changed.

When using React hooks there is no concept of onMount because the idea of only running some code on mount leads to writing non-resilient components, components that do one thing when they mount, and then don’t take prop changes into account.

Beautiful, except that switching albums does not update the PhotoGrid. This is not the automatic reactivity we were promised by Svelte.

Using another reactive statement with $effect we have Svelte automatically handle subscribing and unsubscribing to the store

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

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

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

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.

A “solution” to GR is more like a model in logic: it may satisfy a theory’s axioms but have other properties that are contingent (unless the theory is categorical, meaning that all of its models are isomorphic).

Safiya Noble, Algorithms of Oppression (New York: New York University Press, 2018). See also Mozilla’s 2019 Internet Health Report at https://internethealthreport.org/2019/lets-ask-more-of-ai/.

So that’s already a huge advantage over other platforms due the basic design. And in my opinion it’s got advantages over the other extreme, too, a pure peer-to-peer design, where everyone would have to fend for themselves, without the pooled resources.

“INFORMATION RULES”—published in 1999 but still one of the best books on digital economics—Carl Shapiro and Hal Varian, two economists, popularised the term “network effects”,

In the Ars memorandi noua secretissima, published in 1500 or 1501,20 Jodocus Weczdorff de Triptis (Weimar) inserted an alphabetical list of words, similar to that of Celtis, but he simply suggested that it could be used as a memory house without any scope for our private associations. Moreover, the alphabetic table of Celtis was included in the famous Margarita philosophica nova of Gregor Reisch, which was probably the most popular handbook of the artes scholars in the fi rst two decades of the 16th century.

“The Art of Memory in Late Medieval East Central Europe (Bohemia, Hungary, Poland): An Anthology,” co-written by Lucie Doležalová, Rafał Wójcik and myself.

In 1945 Jacques S. Hadamard surveyed mathematicians to determine their mental processes at work by posing a series of questions to them and later published his results in An Essay on the Psychology of Invention in the Mathematical Field.

MyScript MathPad

In April of 2019, at a digital learning conference, Manuel Espinoza spoke with educators, technologists, and annotation enthusiasts about R2L.d-undefined, .lh-undefined { background-color: rgba(0, 0, 0, 0.2) !important; }.d-undefined, .lh-undefined { background-color: rgba(0, 0, 0, 0.5) !important; }1Nate Angell and “the role that Hypothesis plays in human rights work.”

Horwitz argued a fairly radical point, which I think never received wide enough recognition due to the subject matter and his extremely difficult (dense and dry) style.  He said, “I seek to show that one of the crucial choices made during the antebellum period was to promote economic growth primarily through the legal, not the tax, system, a choice which had major consequences for the distribution of wealth and power in American society”

Universal Design for Learning: Theory and Practice by Meyer, Rose, and Gordon (a book recognized as the core statement about UDL, which you can read for free) walks us through how educators actively change their practice to become more inclusive and helps us weigh choices in terms of how we create unnecessary barriers:

Solid supports templating in 3 forms JSX, Tagged Template Literals, and Solid's HyperScript variant.

So while Solid's JSX and might resemble React it by no means works like React and there should be no illusions that a JSX library will just work with Solid. Afterall, there are no JSX libraries, as they all work without JSX, only HyperScript or React ones.

Unfortunately people lack the the time to invest to really understand those things

If there was a place I thought reactivity would be weak, I embraced it and I worked on it until I was happy with the results.

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

but everything they were doing started to make sense

I kept on wanting them to work like Fine-Grained reactivity, since it was much more intuitive.

Vue was always felt contrived for me.

I couldn't land on how I wanted to box primitives. Should I use a getter/setter, or function form like Knockout, or explicit get/set like MobX? These were all ugly.

Over time Adam, Surplus' creator, had less and less time to spend on the project and I decided to take my own shot.

I started Solid years ago before I thought anyone would be interested in using it. I only started promoting it because it had already achieved the goals I had set out for it.

Templates are prone to unnoticed runtime errors, are hard to test, and are not easy to restructure or decompose.

In contrast, Javascript-made templates can be organised into components with nicely decomposed and DRY code that is more reusable and testable.

The $: can also be used to trigger effects.

We can run effects when some data changes using watchEffect - it takes a function that runs whenever a reactive value used inside changes.

MobX - for me personally MobX is a far better way to manage state than React Hooks. It doesn't care about the UI layer so it can be used outside the React ecosystem, and it's simple to mutate data.