143 Matching Annotations
  1. Jun 2022
    1. the orbital decay rate is large enough to compensate for the first effect and to greatly reduce the risk of the tethered system colliding with other spacecraft.

      tethers cross wection vs orbitdal time pros

    2. Po
    3. As a matter of fact

      performance of tethers tethers are meant to be included in spacecraft design?

  2. Apr 2022
    1. ReconfigBehSci on Twitter: ‘RT @syramadad: C.D.C. Recommends Covid Vaccines During Pregnancy “Only 23% of pregnant women have received even 1 dose of Covid vaccine in…’ / Twitter. (n.d.). Retrieved 23 August 2021, from https://twitter.com/SciBeh/status/1427376304349798400

  3. Jan 2022
  4. Nov 2021
    1. This doesn't solve the problem of supporting where the users are; not everyone wants to use a rolling release, not everyone has the same kernel version, and so on. Not all distros support deb packages.If everyone was on Arch, then AUR would solve everyone's problem. If everyone was on Fedora, then RPM would solve everyone's problem but we don't have that universal packaging system.Freedom to pick and choose what you want to use on Linux is what makes it fun but for people that are trying to develop software and share it with their customers on linux, it's super complicated; they don't have a way to ship software to everyone in one simple package.Software devs can't just ship a deb package. That eliminates the large number of RPM based users such as Fedora, RedHat Fedora Enterprise, CentOS Stream or other distros. Then you have the Arch users, etc.That's what Flatpack/snap/appimage can help with.
    2. packaging is difficult to maintain on linux with so many different distros that software companies to support.Flatpak, snap, and appimage makes it easier to ship once for a lot of distros that support them.
  5. Oct 2021
    1. We were just trying to do what we could to help our community,' said [Hafsa] Islam, who helped treat wounded protesters.

      this is positive because they are trying to help people out.

    1. Racial bias is often hidden, unintentional and systemic. That means that it is actually possible to create racist impact, even if there’s no easily identifiable racist behind the curtain.

      this is true and positive

  6. Sep 2021
    1. Melamine is considered the black sheep of the sheet goods’ family by most carpenters. Typically because it creates a lower quality cabinet than other materials. But, also because it is so darn hard to construct with without getting chips. However, melamine does have a place and a purpose, and if you know how to build with melamine, you can produce some budget-friendly spaces.
    1. From my point of view, this approach will help you to write cleaner code. Also, it will help to maintain the project. For instance, moving a file from the current directory to another will cause fewer problems, because every file uses an absolute path instead of a relative one. Last but not least, it helps you during development.
    1. Update API usage of the view helpers by changing javascript_packs_with_chunks_tag and stylesheet_packs_with_chunks_tag to javascript_pack_tag and stylesheet_pack_tag. Ensure that your layouts and views will only have at most one call to javascript_pack_tag or stylesheet_pack_tag. You can now pass multiple bundles to these view helper methods.

      Good move. Rather than having 2 different methods, and requiring people to "go out of their way" to "opt in" to using chunks by using the longer-named javascript_packs_with_chunks_tag, they changed it to just use chunks by default, out of the box.

      Now they don't need 2 similar but separate methods that do nearly the same, which makes things simpler and easier to understand (no longer have to stop and ask oneself, which one should I use? what's the difference?).

      You can't get it "wrong" now because there's only one option.

      And by switching that method to use the shorter name, it makes it clearer that that is the usual/common/recommended way to go.

  7. Aug 2021
  8. Jun 2021
    1. That’s not the only way of writing end-to-end tests in Rails. For example, you can use Cypress JS framework and IDE. The only reason stopping me from trying this approach is the lack of multiple sessions support, which is required for testing real-time applications (i.e., those with AnyCable 😉).
    1. I'm not sure why MSFT decided to change these codes in the first place. While it might have been a noble goal to follow the IETF standard (though I'm not really familiar with this), the old codes were already out there, and most developers don't benefit by the new codes, nor care about what these codes are called (a code is a code). Just the opposite occurs in fact, since now everyone including MSFT itself has to deal with two codes that represent the same language (and the resulting problems). My own program needs to be fixed to handle this (after a customer contacted me with an issue), others have cited problems on the web (and far more probably haven't publicised theirs), and MSFT itself had to deal with this in their own code. This includes adding both codes to .NET even though they're actually the same language (in 4.0 they distinguished between the two by adding the name "legacy" to the full language name of the older codes), adding special documentation to highlight this situation in MSDN, making "zh-Hans" the parent culture of "zh-CHS" (not sure if it was always this way but it's a highly questionable relationship), and even adding special automated code to newly created "add-in" projects in Visual Studio 2008 (only to later remove this code in Visual Studio 2010, without explanation and therefore causing confusion for developers - long story). In any case, this is not your doing of course, but I don't see how anyone benefits from this change in practice. Only those developers who really care about following the IETF standard would be impacted, and that number is likely very low. For all others, the new codes are just an expensive headache. Again, not blaming you of cours
    2. I'm not sure why MSFT decided to change these codes in the first place. While it might have been a noble goal to follow the IETF standard (though I'm not really familiar with this), the old codes were already out there, and most developers don't benefit by the new codes, nor care about what these codes are called (a code is a code).
    1. And this has some immediate benefits: more efficiency, significantly faster to process, supports indexing (which can be a significant advantage, as we'll see later), simpler schema designs (replacing entity-attribute-value (EAV) tables with jsonb columns, which can be queried, indexed and joined, allowing for performance improvements up until 1000X!)
    1. >> We have that already, it's named 'json_each_text' > Apparently you haven't looked at json parse/deparse costs ;P Well, a PL function is gonna be none too cheap either. Using something like JSON definitely has lots to recommend it --- eg, it probably won't break when you find out your initial spec for the transport format was too simplistic.
  9. May 2021
    1. They also let us make assumptions about relative relationships between folders during development.
    2. Monorepos let us version our back-end with our front-end, making compability easy with combined builds and deployments using a shared CI/CD pipeline.
    1. The advantage of this technique over the Synchronizer pattern is that the token does not need to be stored on the server.
    1. Components are the core of MJML. A component is an abstraction of a more complex email-responsive HTML layout. It exposes attributes, enabling you to interact with the final component visual aspect.
  10. Apr 2021
  11. Mar 2021
    1. One part of React that I've always championed is how it's just JavaScript. I like that in React you don't use a distinct template syntax and instead embed JavaScript, compared to Svelte's templating language
    1. In a 1772 letter to Joseph Priestley, Franklin lays out the earliest known description of the Pro & Con list,[100] a common decision-making technique, now sometimes called a decisional balance sheet:

      I still use this method today. In my job, we use it to decide on possible courses of action - weighing the pros and cons of each against another.

    1. Using multiple termini has three magnificent, beautiful advantages.
    2. Additionally, you may add debugging steps, error handler or rewire the conditions dynamically without touching the original snippet.
    3. the explicit modelling has one massive advantage: all possible outcomes of the nested activity are visible and have to be connected in the outer diagram
  12. Feb 2021
  13. Jan 2021
    1. And this way also fits more with data down, actions up.
    2. So you might ask what is the benefit of using the event dispatcher over just passing a prop down? In some scenarios, you will need to add an action to a button that is 3 or more components down and passing a prop all that way is considered prop drilling (it is frowned upon by some, meh each to their own). However in the case of using an event dispatcher, even though these events don’t bubble, we can easily pass them up using a shortcut that Svelte has.
    3. With this setup, we can create a default action that should take place if one wasn’t passed down.
    1. The upside to snaps is they make installations simpler because they avoid the heartache of dependency hell. This is what occurs when a new application can’t run either because a required resource isn’t available, it’s the wrong version, or its installation overwrites files required by existing applications so they can’t run.
    1. Progress is made of compromises, this implies that we have to consider not only disadvantages, but also the advantages. Advantages do very clearly outweigh disadvantages. This doesn’t mean it perfect, or that work shouldn’t continue to minimize and reduce the disadvantages, but just considering disadvantages is not the correct way.
    2. None of what I’ve said is provided out of the box with apt/deb, and they can only be done in ways that are way to much complex for most non-technical users and in some points they require more work, and some things are simply not available with apt/deb, like the possibility to isolate dependencies, app confinement at the level snaps provide, the possibility to use the same package on other distros (including those that don’t have apt/deb) and different versions of the distro (same package will work on old and new versions independently on how it was built…
    3. This example of the chromium really shows that unless snaps or other similar format was used, applications would have to be sometime very heavily patched to work on older versions of systems to the point that it generates so much work that it would not be worth do to it otherwise, or at least not worth when the snap option exists and doesn’t require that much more work.
    4. snaps have many benefits that are huge: automatic updates List item shorter delivery times between develper and user possibility to use tracks and choose how much on the bleeding edge you want to be way more security and privacy, less dependency issues software available on the same versions independently of distributions and versions of distributions
    5. If folks want to get together and create a snap-free remix, you are welcome to do so. Ubuntu thrives on such contribution and leadership by community members. Do be aware that you will be retreading territory that Ubuntu developers trod in 2010-14, and that you will encounter some of the same issues that led them to embrace snap-based solutions. Perhaps your solutions will be different. .debs are not perfect, snaps are not perfect. Each have advantages and disadvantages. Ubuntu tries to use the strengths of both.
    1. The best thing about an open source operating system, such as Linux, is that you can customize it as much as you want, ranging from default applications such as file managers, music players, web browsers, and text editors etc. to more vital system components such as the kernel, display managers, and terminal consoles. You can do this simply by downloading new application software and replacing the old ones with that, or editing system components by making changes in the source code of your operating system. The display manager is one such system component that you can replace simply by running a few commands mentioned in this article.
  14. Dec 2020
    1. People really don't stress enough the importance of enjoying what you're programming. It aids creativity, makes you a better teammate, and makes it significantly easier to enter a state of flow. It should be considered an important factor in choosing a web development framework (or lack thereof). Kudos!
    1. 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.
    1. 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.
    1. 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).
  15. Nov 2020
    1. After that, the app works like an SPA. It's got better SEO because when a search engine bot asks for a page, the server returns the whole rendered HTML page, with content and meta tags.

      Not sure they have a "hard" time (since they can just run/render the JS too), but harder time, yes..

    1. SVG has the advantage that integrates very well with Svelte, since it’s an XML and the nodes can be managed as if they were HTML. On the other hand, Canvas is more efficient, but it has to be generated entirely with JavaScript.
    1. They are rapid to develop, cross-platform and responsive by nature. JavaScript provides a lot of frameworks (such as Vue, React) and dedicated front-end component libraries to boost productivity (Bootstrap, Material UI). You write your code once and deploy you application on every platform;
    2. These apps combine the best of web and native solutions:
    3. Progressive Web Apps can be installed on most devices like native apps. They are meant to be reliable (work on each platform, even offline), fast and provide a native-like user experience.
    1. You may know several Procfile process management tools, but Overmind has some unique, extraterrestrial powers others don't:
  16. Oct 2020
    1. Personally, I rather like the idea of typing into a field, backspacing to undo what you just typed, and having the field (and form) go back to being pristine. Aside from that aesthetic difference, my definition has the practical implication that it lets you know if you need to save the record or not.
    1. Abstract roles are provided to help with the following: Organize the role taxonomy and provide roles with a meaning in the context of known concepts.Streamline the addition of roles that include necessary features.
    1. 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.
    1. With Angular 2 we can debounce using RxJS operator debounceTime() on a form control's valueChanges observable:

      What's the React/Svelte equiv. pattern for this?

    1. This is exactly what we need the vDOM for — we might not need it for reactive state updates, conditional rendering or list rendering, but as long as we have it we can treat our component hierarchy as fully dynamic and controllable object. You cannot code a serious fully declarative app without this feature.
    1. If you are interested in a library that has the discipline of React, transparent implementation that doesn't cut corners for easiness, and all the performance to back it up maybe SolidJS is the library for you.
  17. Sep 2020
    1. Finally (and most exciting to me), Scoped CSS is ideal for working within Content Management Systems where you have much less flexibility for adding unique markup to common templated areas, or no access to the existing stylesheets.
    1. Being able to use an empty file as a Svelte component was useful during refactoring, because I could just create a placeholder file for the new component, import it and start using it
    1. Inline styles can't target states like hover or focus, but Tailwind's pseudo-class variants make it easy to style those states with utility classes.
    2. Your CSS stops growing. Using a traditional approach, your CSS files get bigger every time you add a new feature. With utilities, everything is reusable so you rarely need to write new CSS.
    3. Making changes feels safer. CSS is global and you never know what you're breaking when you make a change. Classes in your HTML are local, so you can change them without worrying about something else breaking.
    1. Also, Rollup, which I use in the article as a bundler is pretty slow. Why? Because it needs to re-compile the whole shebang every time you change a file. It produces very small and efficient bundles though.
  18. Jul 2020
    1. In some frameworks you may see recommendations to avoid inline event handlers for performance reasons, particularly inside loops. That advice doesn't apply to Svelte — the compiler will always do the right thing, whichever form you choose.
  19. Jun 2020
    1. State management is also easier. Instead of importing hooks and using setters, you just define a property within the script tags. You then change the value by re-assigning it (not mutating the original value).
    2. But it’s impossible to argue with the value binding. You don’t have to worry about defining the value property and an onChange event for an input box in Svelte, bind:value does it all
    1. e present a protocol for secure online com-munication, called “off-the-record messaging”, which hasproperties better-suited for casual conversation than do sys-tems like PGP or S/MIME.
  20. May 2020
    1. See this Hacker News comment thread for more discussion of the issues that might arise and some pro/con comparisons of using Alpine-based images.
    1. After the initial backup, future backups are differential, both in the files that are transferred and the files that are stored on your behalf.

      I guess git can help with the differential part of the backup, but how exactly does it? In order for it to help with transfer from the subject server, wouldn't it have to keep the git repo on that server? Otherwise wouldn't it have to transfer everything to the remote cloud git repo so that git can do the diff there?

      Makes me wonder if simple rsync wouldn't be more efficient than all this.

  21. Apr 2020
    1. The “universal” label that has been slapped on to it is superfluous, but it does have its merits. Now that we have a commonly known term to refer to environment agnostic JavaScript code, it allows library authors to list it as a feature and be fashionable doing it. I’m happy with the term “universal” being fashionable because it makes developers think about their dependencies on the runtime environment. In the end this will help the JavaScript ecosystem mature and allow libraries to be used everywhere.
    1. A language that features polymorphism allows developers to program in the general rather than program in the specific. $(document).ready(function() { recordAdModuleData(2964, "impressions","Dictionary Ad"); });
    2. polymorphism cuts down the work of the developer because he can now create a sort of general class with all the attributes and behaviors that he envisions for it. When the time comes for the developer to create more specific subclasses with certain unique attributes and behaviors, the developer can simply alter code in the specific portions where the behaviors differ. All other portions of the code can be left as is.
    1. minitest doesn't reinvent anything that ruby already provides, like: classes, modules, inheritance, methods. This means you only have to learn ruby to use minitest and all of your regular OO practices like extract-method refactorings still apply.
    1. Tired of wasteful printing? Teachers save valuable time by using Kami, enabling them to enhance workflow and collaborate with their students in real time. 
  22. Mar 2020
    1. This method is easier to implement and it’s very high-performing in terms of load speed
    2. Directly blocking the vendor scripts (using another prior blocking method), then executing them only after consent has been collected. This method requires more implementation work and it’s a bit slower in terms of execution time, but it allows personalized ads to be served from the first page view (where consent hasn’t been collected yet) and gives you more direct and solid control in regards to ensuring compliance.


      • allows personalized ads to be served from the first page view (where consent hasn’t been collected yet)
      • gives you more direct and solid control in regards to ensuring compliance.
    1. Don't be discouraged when you get feedback about a method that isn't all sunshine and roses. Facets has been around long enough now that it needs to maintain a certain degree of quality control, and that means serious discernment about what goes into the library. That includes having in depth discussions the merits of methods, even about the best name for a method --even if the functionality has been accepted the name may not.

      about: merits

    1. It let sets of people work with the same copy of a file, instead of (for example) having to copy the file, and hope their copy was up to date.
  23. Dec 2019
    1. The main benefit I can see to having .bashrc sourced when running a (non-interactive) remote command is that shell functions can be run. However, most of the commands in a typical .bashrc are only relevant in an interactive shell
    2. The user's usual setup (command aliases, environment variables, umask, etc.) are in effect when remote commands are run. The common practice of setting an account's shell to /bin/false to disable it will prevent the owner from running any commands, should authentication still accidentally succeed for some reason.