Bret Victor: email (9/3/04) Interface matters to me more than anything else, and it always has. I just never realized that. I've spent a lot of time over the years desperately trying to think of a "thing" to change the world. I now know why the search was fruitless -- things don't change the world. People change the world by using things. The focus must be on the "using", not the "thing". Now that I'm looking through the right end of the binoculars, I can see a lot more clearly, and there are projects and possibilities that genuinely interest me deeply.

The negative indirect effects of additional land-use change may outweigh the positive direct effects on global climate and biodiversity, so that a large-scale switch to organic farming in the EU could possibly turn out to be a disservice to global sustainability.

organic farming often requires more land than conventional farming for the same quantity of food output.

The complex typewriting effect is abstracted away in a neat function, out of site and out of mind.

this action is re-usable. Anytime you want a typewriter effect added to an element, you just import the function and apply it. So elegant.

Some call them the lifecycle methods of elements which I think is an apt description.

Finally, I think Actions are great for animations, because you will definitely need to apply the same logic to many different elements. One of my favorite examples are FLIP animations, where a change in DOM position can be animated. For example shuffling a list of items. I will not dive deep into the topic in this article: I've written about some techniques in this article about FLIP animations in React and in this article about how to create spring animations with Web Animation API. Although they are not about Svelte, at the end of the day it all boils down to manipulating the HTML element directly. And Svelte Actions are a great place to do it.

But you can get quite close to directly updating CSS with Actions!

export function autofocus(node) { node.focus(); } That's it. This is a legitimate Svelte Action!

For example, if your machine has a lot of RAM doesn't mean all apps should then use as much of it as possible.

In addition, Google designed Chromium to be easy and intuitive for users, which means they compromise on transparency and control of internal operations.

This function allows you to modify (or replace) a fetch request for an external resource that happens inside a load function that runs on the server (or during pre-rendering). For example, your load function might make a request to a public URL like https://api.yourapp.com when the user performs a client-side navigation to the respective page, but during SSR it might make sense to hit the API directly (bypassing whatever proxies and load balancers sit between it and the public internet).

And on any given day, developing with Svelte and its reactive nature is simply a dream to use. You can tell Svelte to track state changes on practically anything using the $: directive. And it’s quite likely that your first reactive changes will produce all the expected UI results.

From a media point of view, Genius was offensive for its initial underlying claim: that it was okay to take anyone’s content for zero compensation, so long as it “added transformative value” by tacking on a comment box where people could say it sucked.

Ease of Use Write your model almost as you would on paper and Dynare will take care of the rest!

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.

Ontologies are inseparable from the communities in which they are being created and used [25].

One good use for /dev/tty is if you're trying to call an editor in a pipeline (e.g., with xargs). Since the standard input of xargs is some list of files rather than your terminal, just doing, e.g., | xargs emacs will screw up your terminal. Instead you can use | xargs sh -c 'emacs "$@" </dev/tty' emacs to connect the editor to your terminal even though the input of xargs is coming from elsewhere.

An extensible plugin architecture allows for customizing your workflow or even making Yarn a package manager for non-JavaScript projects.

apart from [Websockets], which is unnecessarily complex for non-browser applications

It’s fun but when would we ever use things like this in actual code?When it’s well tested, commented, documented, and becomes an understood idiom of your code base.We focus so much on black magic and avoiding it that we rarely have a chance to enjoy any of the benefits. When used responsibly and when necessary, it gives a lot of power and expressiveness.

Monorepo use cases

for cpp_file in *.cpp; do gcc -c $$cpp_file & done; wait This gives much finer control than make -j.

There is one very important reason for enabling job control to be useful inside scripts: the side-effect it has of placing background processes in their own process groups. This makes it much, much easier to send signels to them and their children with one simple command: kill -<signal> -$pgid. All other ways of dealing with signaling entire trees of processes either involve elaborate (sometimes even recursive) functions, which are often bugnests, or risk killing the parent in the process (no pun intended).

You particular circumstances may or may not warrant a way different from what lhunath (and other users) deem "best practices".

Provides a template for future specific classes

This page is currently in public beta mode. I'm am trying to get feedback from multiple people(including you) before I publish it. To facilitate the feedback submission, I have added a highlighting and commenting option. To use that, just select any text(for eg, double click on this: DOUBLE CLICK ME). When you get a login prompt, use this login details... Username: zettelkasten Password: notes If you have any corrections or suggestions, please select the text and add a comment using this system.

Deferment is the delay of grazing to achieve a specific management objective (Society for Range Management 2004). Skovlin (1984) suggests that deferring use until the late season (fall), until restoration of habitat is ac-ceptable, offers a good measure of protection without great expense.

The emphasis was made on a raw CDP protocol because Chrome allows you to do so many things that are barely supported by WebDriver because it should have consistent design with other browsers.

they handled this with 4 1x dynos on Heroku (before switching to AnyCable they had 20 2x dynos for ActionCable).

FYI, my use case is having clickable links in the mail generated by the integration tests.

For me the diagrams make it easier to talk about what the tests do without getting bogged down by how they do it.

These tests should only be used when: the functionality/component being tested is small the internal state of the objects/database needs to be tested it cannot be tested at a lower level

Jest provides useful matchers like toHaveLength or toBeUndefined to make your tests more readable and to produce more understandable error messages.

Thanks, this was just what I was looking for! This is a perfect appropriate use of instance_eval. I do not understand the nay-sayers. If you already have your array in a variable, then sure, a.reduce(:+) / a.size.to_f is pretty reasonable. But if you want to "in line" find the mean of an array literal or an array that is returned from a function/expression — without duplicating the entire expression ([0,4,8].reduce(:+) / [0,4,8].length.to_f, for example, is abhorrent) or being required to assign to a local, then instance_eval option is a beautiful, elegant, idiomatic solution!!

instance_eval is analogous to using tap, yield_self, … when you are dealing with a chain of method calls: do use it whenever it's appropriate and helpful! And in this case, I absolutely believe that it is.

instance_eval lets you run the code while only specifying a once, so it can be chained with other commands. I.e. random_average = Array.new(10) { rand(10) }.instance_eval { reduce(:+) / size.to_f } instead of random = Array.new(10) { rand(10) }; random_average = random.reduce(:+) / random.size

also it's can be helpful for geo deploying when your browser should get access to closest API by GeoDNS but server part can touch neighborhood server or same server.

If you would like to make a code change, go ahead. Fork the repository, open a pull request. Do this early, and talk about the change you want to make. Maybe we can work together on it.

µ

Make it easier to manage people and control visibility. Give people different permissions depending on their group membership.

Organize large projects. For large projects, subgroups makes it potentially easier to separate permissions on parts of the source code.

Bill Withers

Use cases: Volumes are most useful when you need more storage space but don’t need the additional processing power or memory that a larger Droplet would provide, like: As the document root or media upload directory for a web server To house database files for a database server As a target location for backups As expanded storage for personal file hosting platforms like ownCloud As components for building more advanced storage solutions, like RAID arrays

I used to pull stunts like this all the time as soon as tables came. Really ugly, and may seriously embarrass any validator you run it trough: overlapping table cells. Works in most browsers though and even without css.

No, most css doesn't work in emails, stick to tables and images.

For now though, you're stuck with <table> and CSS2 support for your layouts.

I hate to be the guy who will destroy your day but... Tables. You need to work with nested tables/cells. If you think Gmail is annoying you will cry in agony if you also need Outlook support.Work with the good old HTML from the early 2000's. That's the only way to be sure everything will work as intended.Anything else will mostly result in a horrible mess, broken design and incompatible layouts.

(And please, no "use a different email design service" answers, I don't have control over that)

I would try designing your mail-template as "normal" as possible. Tables help a lot for example (yuck).

In a study of 34 grazing systems in operation for 10-20 years in southwestern Montana, Myers (1989a) found timing of grazing, duration of use, and frequency of fall grazing were important factors in successful management (Table 3). The effectiveness of livestock grazing management was judged based on the vigor, regeneration, and utilization of woody species, as well as on bank stability.

These example are for Rails applications, but there is no dependency on Rails for using this gem. Most of the examples are applicable to any Ruby application.

This gem uses a Rack middleware to clear the store object after every request, but that doesn't translate well to background processing with Sidekiq. A companion library, request_store-sidekiq creates a Sidekiq middleware that will ensure the store is cleared after each job is processed, for security and consistency with how this is done in Rack.

With Stack Overflow for Teams being a flexible platform, we’ve seen customers use it for a wide variety of use cases: A platform to help onboard new employees A self-serve help center to reduce support tickets Collaboration and documentation to drive innersource initiatives Breaking down silos and driving org wide transformation like cloud migration efforts A direct customer support platform Enable people who are working towards a common goal, whether a startup or a side project, to develop a collective knowledge base

What produces that text, and what do you want to use it for?

If it's a list of actual pathnames, just replacing spaces by newlines may obviously mangle pathnames that contain embedded spaces, such as /User/myself/VirtualBox VMs/.

The standard ext4 Linux file system also allocates space for a file-creation timestamp in its internal file system structures, but this hasn’t been implemented yet. Sometimes, this timestamp is populated, but you can’t depend on the values in it.

If you’re installing new sod, you may use a light roller to make sure the pieces come into close contact with soil for the roots to grow and take hold.

There are times when you may need to flatten a bumpy lawn. For example, a golf course or a cricket pitch may be rolled to attain a smooth, level surface for playing. This is when a lawn roller may be needed.

To make sure that participants couldn’t learn and predict where text field alternatives might show up during the test, we randomized the order in which we presented those text fields.

Of course, there is no reason why you can't use <aside> for all sidenotes, if it makes your code simpler. Think of it as civil disobedience. :)

This is a great application for using route constraints.

Not enjoying Xcode, Amir used RubyMotion instead. Amir had real-world experience with Xcode and Objective-C, but didn't like it at all. Amir also has a Ruby background and went with RubyMotion to build A Dark Room. The command-line interface, the testing framework, the gems libraries and the CocoaPods integration and the freedom to use any text editor contributed to his decision.

ProMotion is a RubyMotion gem that makes iOS development more like Ruby and less like Objective-C.

Some pesky non-human users (namely computers) have taken to “hotlinking” assets via the raw view feature — using the raw URL as the src for a <script> or <img> tag.

The key point is that this is a feature to improve the experience of our human users.

The problem is that these are not static assets. The raw file view, like any other view in a Rails app, must be rendered before being returned to the user. This quickly adds up to a big toll on performance. In the past we’ve been forced to block popular content served this way because it put excessive strain on our servers.

Just as we've become super-human thanks to telephones, calendars and socks, we can continue our evolution into cyborgs in a concrete jungle with socially curated bars and mathematically incorruptible governance.

we should eagerly anticipate granting ourselves the extra abilities afforded to us by Turing machines

Stop thinking of the ideal user as some sort of honorable, frontier pilgrim; a first-class citizen who carries precedence over the lowly bot. Bots need to be granted the same permission as human users and it’s counter-productive to even think of them as separate users. Your blind human users with screen-readers need to behave as “robots” sometimes and your robots sending you English status alerts need to behave as humans sometimes.

Application: 3-D Shape RegistrationAn important problem in model-based recognition is to find the transformation of a set of datapoints that yields the best match of these points against a shape model. The process is oftenreferred to asdata registration. The data points are typically measured on a real object by rangesensors, touch sensors, etc., and given in Cartesian coordinates. The quality of a match is oftendescribed as the total squared distance from the data pointsto the model. When multiple shapemodels are possible, the one that results in the least total distance is then recognized as the shapeof the object.Quaternions are very effective in solving the above least-squares-based registration problem.

The codebase for Pomodone makes more sense to me in Svelte, not React. I find it easier to navigate and work with.

React and Svelte are very similar in many ways, but what I've found is that in all the little ways that they are different, I prefer Svelte.

This isn't really a downside to React; one of React's strengths is that it lets you control so much and slot React into your environment

There is obvious connections between the flow paths of a use case and its test cases. Deriving functional test cases from a use case through its scenarios (running instances of a use case) is straightforward.

With content based upon an action or event flow structure, a model of well-written use cases also serves as an excellent groundwork and valuable guidelines for the design of test cases

Use cases are not only texts, but also diagrams, if needed.

Currently, I’m working on designing the interfaces and it’s real fun!

This could be an operation, a workflow, or hand-baked Ruby code completely unrelated to Trailblazer.

And it’s tempting for engineers to think decentralising the Web can be achieved with technology. But really, it’s people who will make it happen. Rather than staying put in our little filter bubbles, we can burst out of them — and be radically sociable, delinquent, and make a scene.

“Follow your blisters” implies something that you come back to so many times that you eventually move past the blister stage, into toughened skin. Eventually, the activity “marks you” through use and practice, and you develop a special competence. When you practice an activity a bit more obsessively than other people, you build unique character – you earn some wear and some healing that makes you idiosyncratic, and a little unbalanced.It is something that you don’t need to put on your to-do list, something you care enough about to return to repeatedly, even though it causes discomfort. Over time, you develop a layer of protection that enables you to do that something more easily.

It’s an incredibly amount of overhead and waste. Packages increasingly consume more hard drive space, increase installation times

I would much rather have a "cosine" module than a "trigonometry" module because chances are good I only need a small fraction of the utilities provided by the larger trig module.

Write modules for publication, even if you only use them privately. You will appreciate documentation in the future.

Small modules are extremely versatile and easy to compose together in an app with any number of other modules that suit your needs.

Second, I don't agree that there are too many small modules. In fact, I wish every common function existed as its own module. Even the maintainers of utility libraries like Underscore and Lodash have realized the benefits of modularity and allowed you to install individual utilities from their library as separate modules. From where I sit that seems like a smart move. Why should I import the entirety of Underscore just to use one function? Instead I'd rather see more "function suites" where a bunch of utilities are all published separately but under a namespace or some kind of common name prefix to make them easier to find. The way Underscore and Lodash have approached this issue is perfect. It gives consumers of their packages options and flexibility while still letting people like Dave import the whole entire library if that's what they really want to do.

This is not a physical phenomenon: the software does not actually decay, but rather suffers from a lack of being responsive and updated with respect to the changing environment in which it resides.

To the consternation of some users, 3.x employed Unicode variable names such as λ, φ, τ and π for a concise representation of mathematical operations. A downside of this approach was that a SyntaxError would occur if you loaded the non-minified D3 using ISO-8859-1 instead of UTF-8. 3.x also used Unicode string literals, such as the SI-prefix µ for 1e-6. 4.0 uses only ASCII variable names and ASCII string literals (see rollup-plugin-ascii), avoiding encoding problems.

Normally you should not register a named module, but instead register as an anonymous module: define(function () {}); This allows users of your code to rename your library to a name suitable for their project layout. It also allows them to map your module to a dependency name that is used by other libraries.

And no need to walk backwards through all these strings which is surprisingly inefficient in Ruby.