Express - 19 $ 🏃‍♀️ Skip the Review Queue 🕒 Published in 3 days 💌 Full Customer Support 💚 Support the team

All standard UI events are forwarded on components, input events ("input" and "change") are forwarded on input components, and all MDC events are forwarded.

It's fast. The Dart VM is highly optimized, and getting faster all the time (for the latest performance numbers, see perf.md). It's much faster than Ruby, and close to par with C++.

In Angular CLI 6 this command has been removed, and it will not come back. Instead there is a new concept called Builders.With the new Angular CLI you can customize the build process by defining your own builders as well as using one of the builders provided by the community.

Just coming here to voice my agreement that these warnings are annoying and exist in other libraries as well. For me this happened with svelma. I didn't write the library code, so I don't have complete control over it even though I agree there is an argument to be had around whether I should be notified anyway. In either case, these warnings should be easily disabled since libraries don't always get updated over night.

Maybe it's also a bug because every warning should be ignorable? Not sure.

I would like the compiler to add a property like canIgnore: false to the warning, if the warning cannot be disabled.

Over 4 million people trust CloudApp

React Final Forms is a great library, an enhanced version of Redux Form

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.

We are looking to use React Final Form in our application at work. Evaluating our options and reading the documentation, we couldn't figure out how to address a specific use case.

you took 4 hours to respond, so I implemented it myself

However, after solving this problem a few times, a pattern appeared.

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}`) }

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.

The flipped meeting — pioneered by innovative companies like Amazon and LinkedIn, and built on the model of the flipped classroom that has been rolled out in universities across the country and around the world.  Flipping your meetings can help you win back time wasted in meetings, ensure that every meeting you attend is productive, and empower your teams to collaboratively make smarter, timelier decisions. See how, in our complete guide to flipping your meetings.

But there is an alternative. The “flipped meeting” approach is revolutionary in its simplicity: Share the informational presentation before the meeting so participants are fully informed up front Focus the meeting on making decisions, opening discussion, and getting work done in the meeting, not afterwards This handbook includes a guide to developing a flipped meeting culture in your organization, including: Pre-meeting communication and information sharing needs In-meeting group management and best practices Ideas for using video to make flipped meetings more efficient Flipping your meetings can help you win back time wasted in meetings, ensure that every meeting you attend is productive, and empower your teams to collaboratively make smarter, timelier decisions.

We rarely, if ever, start with a completely blank file and start writing code. More often that not we start by copying an existing file and then modifying it to get our result.

The reason the bunny theory of code has held up is because of the way software engineers work.

With the new plugin based architectue, the library has really small core. Everything else is built around as a plugin.

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.

Prior to version 6.0, BitTorrent was written in Python, and was free software.

As a result, it is no longer open source.

This is a very unusual pattern and most people don't know you can.

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.

Additionally, if we ever want to standardize more of JSX we need to start moving away from some of the more esoteric legacy behaviors of React.

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 using HTML as the uniform interface, we can separate the interface from the engine.

Since “virtual DOM” is more of a pattern than a specific technology, people sometimes say it to mean different things. In React world, the term “virtual DOM” is usually associated with React elements since they are the objects representing the user interface

Virtual DOM is valuable because it allows you to build apps without thinking about state transitions, with performance that is generally good enough

In the vast majority of cases there’s nothing wrong about wasted renders. They take so little resources that it is simply undetectable for a human eye. In fact, comparing each component’s props to its previous props shallowly (I’m not even talking about deeply) can be more resource extensive then simply re-rendering the entire subtree.

This assumes that the module has been given a well-defined, stable description (the interface in the sense of information hiding).

create patterns & metaphor

Source Code is a UX to interface with the raw machine.

rehype is an ecosystem of plugins for processing HTML to do all kinds of things: format it, minify it, or wrap it programmatically into a document.

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.

Keep the local state isolated.Think about which state is local to a particular UI representation — and don’t hoist that state higher than necessary.

However, although their approaches are different, one thing ASM have in common is their emphasis on network and code pedagogies: that is, trying to help users become coders and technicians, “sociologists of software,” to draw on Simondon (2010), who are far more able to shape ASM to meet their needs. Thus, developers of ASM do more than just make media systems; they teach others how to use them and modify them. As Matt Lee of GNU social argues,it is vitally important to me that anyone can set up a GNU social server on virtually any web hosting. I also want to make it as easy as possible to set up and install. To that end, I will personally help anyone who wants to get set up.

but everything they were doing started to make sense

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.

Picking the best solution is subjective, and I can only offer my point of view, so take this with a grain of salt.

People assume any advocacy for things they're not personally stoked about is "shilling".

I don't even have it on my PC. That's why I didn't test the code myself. Don't have time for everything in this world

PR’s welcome. As I said I don’t have bandwidth to cross check all the bundlers & transpilers combo.

This library exports a single React Hook, useMethods, which has all the power of useReducer but none of the ceremony that comes with actions and dispatchers.

Here's one quick way to test if your application has properly segregated itself between the Model, View, and Controller roles: is your app skinnable? My experience is that designers don't understand loops or any kind of state. They do understand templates with holes in them. Everybody understands mail merge. And if you say, "Apply the bold template to this hole," they kind of get that, too. So separating model and view addresses this very important practical problem of how to have designers work with coders. The other problem is there is no way to do multiple site skins properly if you don't have proper separation of concerns. If you are doing code generation or sites with different skins on them, there is no way to properly make a new skin by simply copying and pasting the old skin and changing it. If you have the view and the logic together, when you make a copy of the view you copy the logic as well. That breaks one of our primary rules as developers: have only one place to change anything.

In 1972 David L. Parnas published a classic paper entitled On the Criteria To Be Used in Decomposing Systems into Modules. It appeared in the December issue of the Communications of the ACM, Volume 15, Number 12. In this paper, Parnas compared two different strategies for decomposing and separating the logic in a simple algorithm. The paper is fascinating reading, and I strongly urge you to study it. His conclusion, in part, is as follows: “We have tried to demonstrate by these examples that it is almost always incorrect to begin the decomposition of a system into modules on the basis of a flowchart. We propose instead that one begins with a list of difficult design decisions or design decisions which are likely to change. Each module is then designed to hide such a decision from the others.”

Domain-driven design separates the model layer “M” of MVC into an application, domain and infrastructure layer. The infrastructure layer is used to retrieve and store data. The domain layer is where the business knowledge or expertise is. The application layer is responsible for coordinating the infrastructure and domain layers to make a useful application. Typically, it would use the infrastructure to obtain the data, consult the domain to see what should be done, and then use the infrastructure again to achieve the results.

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

Sorry this sat for so long!

From npm@5.2.0, npm ships with npx package which lets you run commands from a local node_modules/.bin or from a central cache.

En concreto, el software libre implica que los usuarios tienen las cuatro libertades esenciales: (0) ejecutar el programa, (1) estudiar y modificar el código fuente del programa, (2) redistribuir copias exactas y (3) distribuir versiones modificadas.

I took the same approach with _layout.svelte and not just for the svelte-apollo client. Except I put all of that setup into another module (setup.js) and imported from _layout. I just couldn't stomach having all that code actually in my _layout file. It's for layout, supposedly, but it's the only component that is a parent to the whole app.

I got this working by using _layout.svelte as the point to initialise and set the Client we can then use getClient in each route that uses this layout.

If you need to call the function repeatedly, this is much, much faster than using eval.

Developing software is usually easier if you break your project into smaller separate pieces, since that often removes unexpected interactions and dramatically reduces the complexity of the problems you'll need to solve

After years of copy-pasted, locally-hosted scripts, maybe Bower if you were lucky, npm has finally made it possible to easily distribute client-side packages.

Rollup builds atop Browserify and Webpack's lineage to make it possible to easily consume those packages, while looking to the future of JS modules.

answered

I've committed to using Svelte, so I want to see it become highly adopted and not die or lose steam. For that, I believe we need to build up the ecosystem. Shared components, actions, transitions, etc. which make it easier for ourselves and others to build apps. I feel this will help Svelte continue to grow and will make it a better tool for our jobs. I see actions as one of the needed pieces to make this happen.

I think hooks will be beneficial to the Svelte ecosystem, making sharing code for Svelte apps that solve common problems easier.

Svelte started with no decoupling anywhere, with everything available at compile-time. Then <:Component> introduced separation at the component level -- but they're still coupled at properties. The spread feature would fill that gap. I see it as an intentional separation as opposed to an accidental shot at static analysis.

I have no familiarity with Svelte internals, so much of your talk about what they would do eludes me. I'm just concerned with developer ergonomics

Modern view libraries like React allow teams to build and maintain these components more easily than ever before, but it is still extraordinarily difficult to do so in a fully accessible way with interactions that work across many types of devices.

Forwarding events from the native element through the wrapper element comes with a cost, so to avoid adding extra event handlers only a few are forwarded. For all elements except <br> and <hr>, on:focus, on:blur, on:keypress, and on:click are forwarded. For audio and video, on:pause and on:play are also forwarded.

If you want to listen to an event on some deeply nested component, the intermediate components must forward the event.

Yup, which was released six years ago, is obviously a more popular choice at this time. Zod is smaller in size, probably because it doesn’t have as many APIs as Yup, but it’s sure to grow as more features are developed.

¿Qué opinas?

A small group of computer illiterate politicians, driven by fear and images of dying people have thrown the United Kingdom into chaos. They did this on the evidence of a thirteen year old computer programme written in the C language that has no comments, and that no one has seen or audited to ensure its basic assumptions are correct. This tragic event, which has cost the United Kingdom billions, is a perfect example of why critical software must be open source and open to peer review before it is accepted for any purpose where human life is at stake.

Medical Software Development: Benefits and Implementation Strategy

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.

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

6to5 attempted to ship a quick and dirty TDZ static checking feature but had to retract it immediately afterwards due to various bugs in the algorithm.

but adding logic to the <script> is unfortunate

In general, my focus has shifted from optimization to DX. Partly because Svelte does a lot of the heavy lifting. For things that can be optimized on a need-to basis, I would rarely sacrifice DX.

The language should work for developers, not the other way around.

If component authors were in the habit of expecting a style prop, and applying it to top-level elements, we could do the same thing like so

This has the merit of simplicity and obviousness, but it's not particularly ergonomic: it signals that we don't consider component themeability to be a problem worth solving properly.

There is interactive state as well. What about modals that come up because something is clicked? What is the active tab? Is this menu open or closed? What scroll position are they at? There are infinite permutations of this. Imagine a warning bar that shows up seven seconds after the user logs in to warn user about their expired credit card which contains a custom styled select menu which can be in an open or closed state, but only on the user settings page.

Remember the timing thing? We might think of timing as one generic form of state. There are countless other things that could be state related. Is the user logged in or not? What plan are they on? Is their credit card expired thus showing some kind of special message? Do situational things like time/date/geolocation change state? What about real-time data? Stuff from an API?

And because it's real CSS, rather than some camelCased quotes-everywhere impostor, we can take advantage of the 'tweak in devtools, paste back into our source code' workflow, which I personally couldn't live without.

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.

It’s become increasingly common to divide code into components, rather than by file type. React, for example, allows for the collocation of a components markup and JavaScript. In Svelte, this is taken one logical step further: the Javascript, markup and styling for a component can all exist together in a single `.svelte`​ file

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

These creeping changes help us forget how important our privacy is and miss that it’s being eroded.

Secure-by-default is a great approach, but this is not that. It's not even, we know what's best. It's clean up your act or you're out. You really should provide an opt-in to running with scissors. Maybe like config.opt_in_to_dynamic_routes_you_dumbass = true. 1 Pick your reaction

I too would like to know more about the security concerns that are the motivation to remove these useful dynamic routing components. The only thing I can think off is someone who accidentally exposes a private method public, is there more? The dynamic routes are a great way to keep the routing.rb DRY and avoid unneeded dependencies between the routing and the controller files, it has been quintessential Rails magic since version 1.0, surely there must be more serious security concerns to give up such important benefits? What are they? Do we really need to completely remove this from the code base, when removing it from the default routes.rb already would get you most of the security benefit?

I'm sure the security overlords have our best interest in mind and I'd be happy to change my opinion if someone can explain this tradeoff better. I know I can recreate the functionality for myself but I also like to keep in mind what's best for Rails. Just a hand wavy "we've had this for almost 10 years, but it might become an issue in the future so let's preventively eliminate it" does not seem a good enough reason to cut a feature that can make code much more DRY and elegant.

Sounds like Mixins are on their way out

Many changes, including bug fixes and documentation improvements can be implemented and reviewed via the normal GitHub pull request workflow. Some changes though are "substantial", and we ask that these be put through a bit of a design process and produce a consensus among the Yarn core team. The "RFC" (request for comments) process is intended to provide a consistent and controlled path for new features to enter the project.

For example, to search for text occurrences, I used ack-grep. Later on, I found that there is a faster approach using ag. Then, there is an even faster alternative called ripgrep.

There’s just so much noise small businesses tend to ignore. But in Indonesia, that isn’t the case…yet. The software landscape there is similar to the 1990s in the US. It’s harder to piggyback off of existing software infrastructure — whether it’s payments or platforms — but there’s also a lot of obvious opportunity in software that no one is going after. The same could be said about investing elsewhere in Southeast Asia or in LatAm or Africa. There are fewer startups to compete with for attention, and it’s less of a marketing game than building a software company in the US.

As economist Carlotta Perez describes, we are now in the Deployment Phase of the internet in the US — meaning, we are in-process of exhausting all use cases for internet technologies in the US. What has traditionally happened at the end of a technology phase is oversaturation of investment dollars chasing smaller returns. Valuations go up, returns go down, and investors lose their money. (Sound familiar?) On a company level, what this means is, if not careful, a lot of companies will end up wasting marketing dollars in this type of landscape. Companies in the 2020s, unlike in the 1990s, need to really be performance-marketing driven in order to compete. The end of last year certainly showed us many examples of well-funded companies that could not make the unit economics work. The software industry has become a marketing game.

The RAT model sees software development as an off-line program-construction activity composed of these parts: defining, decomposing, estimating, implementing, assembling, and finishing

Digital work has significantly faster feedback loops for productivity. Software, quite simply, can produce and iterate new things at a daily if not hourly or minute basis.

Stallman has also stated that considering the practical advantages of free software is like considering the practical advantages of not being handcuffed, in that it is not necessary for an individual to consider practical reasons in order to realize that being handcuffed is undesirable in itself.

Free software thus differs from: proprietary software, such as Microsoft Office, Google Docs, Sheets, and Slides or iWork from Apple. Users cannot study, change, and share their source code. freeware, which is a category of proprietary software that does not require payment for basic use.