Therefore, it could be argued that belief regarding the usefulness of technologies could lead to change and ultimately the actual use of digital technologies in teaching and learning.

You’re in good companyTrusted by leaders at some of the world’s most inspired organizations

You can also purchase a Nextcould hosting service, which on one hand may not seem any different from giving your photos over to Google or Apple, but there's a significant difference: Nextcloud storage is demonstrably encrypted, with source code to prove it.

We are unapologetic tinkerers who neither invent the wheel, nor are satisfied with the wheels already at our disposal. The best scholarship and the best pedagogy take the best of what already exists and make it better, at least better for the task at hand. We need to embrace this identity as hackers, acknowledge our indebtedness to those who have gone before us, forsake the illusion that we are creating (can create, should create) something wholly original, but also refuse to take for granted the things that have been passed down to us.

We usually only see people launching projects once they're already done. I'm sure there are countless more unfinished and unlaunched side projects that the world will never know about. Don't let your side project become one of them.

Some devs prefer Svelte’s minimal approach that defers problems to userland, encouraging more innovation, choice, and fragmentation, and other devs prefer a more fully integrated toolkit with a well-supported happy path.

The template language's restrictions compared to JavaScript/JSX-built views are part of Svelte's performance story. It's able to optimize things ahead of time that are impossible with dynamic code because of the constraints. Here's a couple tweets from the author about that

Keep in mind that as a software developer, of any degree, learning is continuous. New technologies, new ways to write code, not so new approaches, persisting patterns. Read books, watch online courses, follow tutorials, keep learning!

Because Jamstack projects don’t rely on server-side code, they can be distributed instead of living on a single server. Serving directly from a CDN unlocks speeds and performance that can’t be beat. The more of your app you can push to the edge, the better the user experience.

Better PerformanceWhy wait for pages to build on the fly when you can generate them at deploy time? When it comes to minimizing the time to first byte, nothing beats pre-built files served over a CDN.

Better contribution workflow: We will be using GitHub’s contribution tools and features, essentially moving MDN from a Wiki model to a pull request (PR) model. This is so much better for contribution, allowing for intelligent linting, mass edits, and inclusion of MDN docs in whatever workflows you want to add it to (you can edit MDN source files directly in your favorite code editor).

I don't think this is what really matters at the end, since whatever is the implementation the goal should be to provide a library that people actually like to use.

Micro is a platform for cloud native development. It addresses the key requirements for building services in the cloud. Micro leverages the microservices architecture pattern and provides a set of services which act as the building blocks of a platform. Micro deals with the complexity of distributed systems and provides simpler programmable abstractions to build on.

A Comprehensive Guide on the Dedicated Team Model: Explaining the Concept, Advantages, and Pitfalls

No program is an island. Every program has to hook into the operating system at some point, if nothing else.

As was mentioned in the comments above, the material design spec for buttons specifies that the text should be uppercase, but you can easily override its CSS property: paper-button { text-transform: none; }

enables passive event listeners by default for some events (see list below). It basically will set { passive: true } automatically every time you declare a new event listener.

There are actually 3 other libraries that implements material in svelte, i hope this to become the community favorite because using MDC underneath it implements correctly Material guidelines.

I'm still deeply working on it every day, i'm around 1/2 month away for a first preview release.

from my point of view, it is (by far) the best way, to build a layer on top https://github.com/material-components/material-components-web . This is also the path that the Angular Material team has taken, although they have already made a huge effort to create the components themselves.

@monkeythedev can your work be used already? I would suggest not yet, i'm still doing core changes every day

@use "@material/theme" with (  $primary: #FEDBD0,  $on-primary: #442C2E);

You could totally just write your own name and not use the name in package.json, this template is made so the users wouldn't need to think about the UMD build.

Who’s Using Snowpack?

Portable... your .name address works with any email or web service. With our automatic forwarding service on third level domains, you can change email accounts, your ISP, or your job without changing your email address. Any mail sent to your .name address arrives in any email box you choose.

If you are a developer and would like to fork, modify and/or contribute to this extesion, then this section is for you.

Used by folks at

Prior work This project uses work done in the awesome-typescript-loader.

The project organization is a bit weird because we have a mono-repository that contains projects and libraries. The projects are grouped by company and by browser / server / universal.

It is impossible to rebuild the base from the Dockerfile as the 3rd party dependencies have changed significantly since 8 months ago when the base was last built. The tags for my base image have been overwritten and I can only restore them from a descendant image. With Docker 1.8 I simply pulled the descendant image, tagged the base layer and I was done. With Docker 1.10+ I'd need to save, then manually construct the base image descriptor and reload it. Doable but sad that it's far more complex.

Allowing parent layer metadata to be saved for a layer, regardless if the parent layer is in the save command, would be a huge win for those of us working on CI/remote systems. Reusing parent layers used to be ridiculously easy. It would be good if we could get some comparably easy way to do it now.

It used to be great that I was able to select a layer from any image and use it as a starting point. Currently, I am given an image that has 4 layers to be stripped off to get to the original base image. The original image is not reconstructable in any other way.

Since yarn already has retries on metadata operations, my perspective is that this PR is about filling in an (inadvertent I assume) gap.

Test plan You need a large NPM package in a private org on the npmjs.org registry. 10MB download size is ideal.

In my opinion, deleting a user is not a function executed by an item on itself but is a function done by the holder of the array. So in your case you would be better of moving the deleteUser up to App.

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.