70 Matching Annotations
  1. May 2024
    1. The content needs to be grounded instated course learning goals and be organized into content segments/modules.a. Structure the course to support the learning goals.b. Arrange the course content in a linear, logical structure, and organize the content intomanageable segments/modules.c. Use consistent organizational structure, color scheme, and textual components throughoutthe course to help students navigate the course.d. Provide course materials (graphics, media, documents, etc.) in accessible formats (ADACompliance for Online Course Design).

      Course organization

    1. For completing tasks such as reading instructions, submit-ting an assignment, and posting to the discussion board,a chronological layout was more efficient. Figures 7 and 8are an example of individual participant’s gaze plot for eachgroup while completing the second task of reading the assign-ment instructions. The visualizations show that when giventhe instruction to complete a task by week or module, thechronological layout was more compelling at guiding partici-pant’s visual attention to the weekly modules on the naviga-tion menu. Not to mention, those in the Chronological groupcommitted fewer mistakes than participants in the Functionalgroup for all instructional activities, with the exception oflocating grades.What was les

      to find instructions, and assignments and discussion boards - modules was the most effective.

    1. Students need space and structure thatwill invite them to engage actively

      reason for modules, Invite student engagement.

  2. Mar 2024
  3. Sep 2023
  4. Dec 2022
  5. Nov 2022
    1. You're likely not using "type": "module" in your package.json, so import statements don't work in svelte.config.js. You have three ways to fix this: Use require() instead (also see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/in-general.md#generic-setup) Rename svelte.config.js to svelte.config.mjs Set "type": "module" in your package.json (may break other scripts)
  6. Nov 2021
  7. Jul 2021
  8. May 2021
    1. It's a chicken-and-egg-like problem: If we use module: 'commonjs', then if any TS files import ES Modules (indirectly in their dependency graph), then Node throws an error because CommonJS modules can not import ES Modules.
    1. CommonJS has served us well for many years, but ESM comes with many benefits, like language-level syntax, browser support, defaults to strict mode, async loading, top-level await, improved static analysis & tree-shaking, and more.
  9. Apr 2021
  10. Mar 2021
    1. But I believe the core philosophy of tiny modules is actually sound and easier to maintain than giant frameworks.
    2. "Functions Are Not Packages" - Well why not?
    3. Small modules are extremely versatile and easy to compose together in an app with any number of other modules that suit your needs.
    4. Write modules that are small. Iterate quickly.
    1. Because the diagrams are .independent of one another, you can study them and improve them one at a time, so that their evolution can be gradual and cumulative. More important still, because they are abstract and independent, you can use them to create not just one design, but an infinite variety of designs, all of them free combinations of the same set of patterns.

      This also applies to [[modules]] in computer systems; and to [[functions]] in programming languages in the functional paradigm (as these are self-contained and side-effect-free).

  11. Nov 2020
    1. Microbundle also outputs a modern bundle specially designed to work in all modern browsers. This bundle preserves most modern JS features when compiling your code, but ensures the result runs in 90% of web browsers without needing to be transpiled. Specifically, it uses preset-modules to target the set of browsers that support <script type="module"> - that allows syntax like async/await, tagged templates, arrow functions, destructured and rest parameters, etc. The result is generally smaller and faster to execute than the esm bundle
    1. If I use import { createEventDispatcher } from 'svelte/internal'; instead of import { createEventDispatcher } from 'svelte'; then it seems to work because it's loading from the same module.
    1. is not required to point to "svelte": "src/main.html" if you're bundling for es, "module": "dist/main.mjs" would suffice. I mean, it's a good thing to provide a single file, not the whole sources again.
    1. But seriously, give snowpack a read to understand the benefits of leaning on standard esm imports, allowing you to avoid a bundling process entirely.
    2. I don't need to support non-esm browsers for most projects and I really like the idea of a super light build process. By removing the complexity of configuration and the overhead of bundling, svelvet makes the development process an optimal experience for myself and hopefully others
    1. Using as * adds a module to the root namespace, so no prefix is required, but those members are still locally scoped to the current document.


      • root namespace (so no prefix is required), but
      • locally scoped (to the current document)
  12. Oct 2020
    1. 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).

      Here: dynamic loading (libraries/functions) meaning: at run time

    2. 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
    1. Uses "ES Modules" and does not support require(). Third party modules are imported via URLs:
    1. In the brave new world of ES6 + JavaScript, we have a syntax that allows us to declare the dependencies of one file to other files in our project i.e the import keyword, as well as the ability to declare the functions, classes, and variables that other files may import i.e the export keyword.
  13. Sep 2020
    1. using modulesOnly behaves exactly as expected when it warns you that the listed npm libraries do not use the ES6 format and are in fact ignored. This option is meant as a way to determine if you still have commonjs libraries in your dependencies that require special treatment via rollup-plugin-commonjs. Your code will probably not work since the listed dependencies will be missing. You should remove modulesOnly and instead add rollup-plugin-commonjs.
    1. 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.
    2. If you've followed React's guide, you've installed react from npm. You can teach Rollup how to find this package within your project's node_modules directory using the rollup-plugin-node-resolve plugin. Since React exports a CommonJS module, you'll also need to convert that into an ES6 module using the rollup-plugin-commonjs plugin.
    3. Rollup is a tool that lets you write your application using ES6 modules, even though you can't publish those modules directly to your users, because native support is only just starting to land in browsers. Rollup compiles your modules into a format that all browsers _do_ understand—a single script file—by, essentially, concatenating files together (while reordering and renaming declarations to preserve scope).
    1. In other words for those tools, you cannot create a package interface where const lib = require("your-lib") yields the same as import lib from "your-lib". With named export mode however, const {lib} = require("your-lib") will be equivalent to import {lib} from "your-lib".
    2. To make sure your ES modules are immediately usable by tools that work with CommonJS such as Node.js and webpack, you can use Rollup to compile to UMD or CommonJS format, and then point to that compiled version with the main property in your package.json file.
    3. ES modules let you freely and seamlessly combine the most useful individual functions from your favorite libraries
    1. Since most CommonJS packages you are importing are probably dependencies in node_modules, you may need to use @rollup/plugin-node-resolve:
    1. This is a demonstration of building a custom D3 4.0 bundle using ES2015 modules and Rollup. Custom bundles can be optimized to contain only the code you need. This example exposes just three fields on the d3 object: d3.event, d3.select and d3.selectAll. The minified and gzipped bundle is only 3,691 bytes, a savings of 93% over the default build!
    1. The module specifier is always fixed. That is, you can’t change what you import depending on a condition. And you can’t assemble a specifier dynamically.
    1. It is good for clarity, i.e. it makes it clear which files are modules, and which are regular JavaScript.
  14. Dec 2019
  15. Nov 2019
    1. One of the more confrontational parts of JavaScript development has always been its module system
  16. Sep 2019
  17. Feb 2017
    1. select proprietary or out-of-tree modules (ex. vitualbox, nvidia, fglrx, bcmwl, etc.)

      If anyone is wondering what other modules they refer to, or how to discover any on your own system, this StackExchange thread on how to identify out-of-tree modules might help.