For example, what if your site has a customer interface and an “admin” interface? If the two have totally different designs and features, then it might be considerable overhead to ship the entirety of the admin interface to every customer on the regular site.

Before we get into what the manifest.js does, let’s look at what it is replacing.

we also wrap them in Failure to solve the second problem: spotting potential exceptions is hard

Not all cases can be covered and easily restored. And sometimes when we will reuse this function for different use-cases we will find out that it requires different restore logic.

But why do we return 0? Why not 1? Why not None? And while None in most cases is as bad (or even worse) than the exceptions, turns out we should heavily rely on business logic and use-cases of this function.

So, the sad conclusion is: all problems must be resolved individually depending on a specific usage context. There’s no silver bullet to resolve all ZeroDivisionErrors once and for all. And again, I am not even covering complex IO flows with retry policies and expotential timeouts.

let's be honest, print-and-play is A LOT of work (printing, cutting, laminating, sleeving, etc) and it is not everyone's cup of tea.

Don’t worry if you get confused at first. Everyone does. I’ve listed some other references at the end that may help. But don’t give up.

So every program starts in the IO monad. From here you can get any input you need, call into relatively "pure" code with the inputs, and then output the result in some way. The reverse does not work. You cannot call into IO code from pure code like you can call into a Maybe function from pure code.

If you ask my former students, they will tell you that as a teacher, my goal is to do nothing. I dream of the day when I can sit at my desk, feet propped up, reading a book, while the classroom bursts with activity and learning around me.

Trailblazer (TRB) is an Open-Source project. Since we want to keep it that way, we decided to raise awareness for the “cost” of our work - providing new versions and features is incredibly time-consuming for us, but we love what we do.

Example (in bash, but my question shouldn't be considered bash-specific):

This is in fact where I started, but this gives me all processes, which is exactly what I don't want.

stolen love from the child and infant and made it the exclusive property of the adolescent and adult

compose(Add, x: x, y: 3)

Add.run(x: x, y: 3)

If ActiveModel deals with your nouns, then ActiveInteraction handles your verbs.

Why is all this interaction code better? Two reasons: One, you can reuse the FindAccount interaction in other places, like your API controller or a Resque task. And two, if you want to change how accounts are found, you only have to change one place.

For this one we'll define a helper method to handle raising the correct errors. We have to do this because calling .run! would raise an ActiveInteraction::InvalidInteractionError instead of an ActiveRecord::RecordNotFound. That means Rails would render a 500 instead of a 404.

Microsoft has the advantage of exclusively serving Yahoo search traffic, powering several digital assistant voice searches, and the ability to target searchers with LinkedIn profile data such as company, job function, and industry.

I'm sure there will be a few other people out there who eventually want something like this, since Interactions are actually a great fit for enforcing consistency in data structures when working with a schemaless NoSQL store, but obviously it's still a bit of a niche audience.

I don't think seeing it in Rails PRs naturally means we should do it blankly. Put it another way, what's the justification in those PRs for doing it?

The rationale is that it's actually clearer to eager initialize. You don't need to worry about timing/concurrency that way. Lazy init is inherently more complex than eager init, so there should be a reason to choose lazy over eager rather than the other way around.

The assert method is used by all the other assertions. It pushes the second parameter to the list of errors if the first parameter evaluates to false or nil.

you mean Action Form, right?

Set your models free from the accepts_nested_attributes_for helper. Action Form provides an object-oriented approach to represent your forms by building a form object, rather than relying on Active Record internals for doing this.

rafaelfranca closed this on Feb 27, 2018

From my perspective the onus is on you to consider not just the words coming out of your mouth, but how they are received.

This column and last month's article are about design. Design, by nature, is a series of trade-offs. Every choice has a good and bad side, and you make your choice in the context of overall criteria defined by necessity. Good and bad are not absolutes, however. A good decision in one context might be bad in another.

Stating that some language feature or common programming idiom (like accessors) has problems is not the same thing as saying you should never use them under any circumstances.

And just because a feature or idiom is commonly used does not mean you should use it either.

Say you have software to keep track of your grocery list. In the 80's, this software would work against a command line and some flat files on floppy disk. Then you got a UI. Then you maybe put the list in the database. Later on it maybe moved to the cloud or mobile phones or facebook integration. If you designed your code specifically around the implementation (floppy disks and command lines) you would be ill-prepared for changes. If you designed your code around the interface (manipulating a grocery list) then the implementation is free to change.

Rather than implement features you might need, you implement only the features you definitely need, but in a way that accommodates change. If you don't have this flexibility, parallel development simply isn't possible.

At the core of parallel development, however, is the notion of flexibility. You have to write your code in such a way that you can incorporate newly discovered requirements into the existing code as painlessly as possible.

with ActiveForm-Rails, validations is the responsability of the form and not of the models. There is no need to synchronize errors from the form to the models and vice versa.

DSLs can be problematic for the user since the user has to manage state (e.g. am I supposed to call valid? first or update_attributes?). This is exactly why the #validate is the only method to change state in Reform.

The reason Reform does updating attributes and validation in the same step is because I wanna reduce public methods. This is to save users from having to remember state.

We think that, although Ruby is a great language for the backend, the view should be written in languages designed for that purpose, HTML and JavaScript.

Let's assume that something in the system has to change (as it rarely does..), and we need to add a new step to the process to the runner

Unlike naming children, coding involves naming things on a daily basis. When you write code, naming things isn’t just hard, it’s a relentless demand for creativity. Fortunately, programmers are creative people.

If we renamed things more often, then it probably wouldn’t be so hard to name them in the first place.

We also find it hard to agree on what good names and bad names look like, which makes it hard to know when renaming improves a name.

This is funny because it’s unexpected. Cache invalidation sounds like a hard thing, while naming sounds more straightforward. The joke works because it violates our expectation that hard things should be technical. It’s also funny because it’s true.

Naming is communication

‘Programs are meant to be read by humans and only incidentally for computers to execute.’

Naming matters for both idealogical and practical reasons.

Naming is just one part of the micro-design activity that we call programming. If design weren’t hard, we wouldn’t find good design so satisfying.

Anyone who has ever tried to name a child knows that naming is hard. Naming things in code is harder. It’s bad enough that you have to commit to a name that someone isn’t going to like. You also have to be able to live with it.

It's difficult because it's a case-by-case basis - there is no one right answer so it falls into subjective arguments.

The underlying data might get changed by another process and then your process that uses the cache will be working with incorrect data

So the hard and unsolvable problem becomes: how up-to-date do you really need to be?

After considering the value we place, and the tradeoffs we make, when it comes to knowing anything of significance, I think it becomes much easier to understand why cache invalidation is one of the hard problems in computer science

The non-determinism is why cache invalidation — and that other hard problem, naming things — are uniquely and intractably hard problems in computer science. Computers can perfectly solve deterministic problems. But they can’t predict when to invalidate a cache because, ultimately, we, the humans who design and build computational processes, can’t agree on when a cache needs to be invalidated.

Cache invalidation is hard because: Everything in life we want to know, changes.Those changes are non-deterministic.

Sometimes humorously extended as “cache invalidation, naming things, and off-by-one errors.”

There’s only one hard thing in Computer Science: human communication. The most complex part of cache invalidation is figuring out what the heck people mean with the word cache. Once you get that sorted out, the rest is not that complicated; the tools are out there, and they’re pretty good.

One reason Turbolinks sites seem faster than traditional web apps is because of its cache. However, the cache can be a source of great frustration. Many of the edge cases we're going to discuss involve the cache in some way.

Turbolinks is a Single-Page Application Turbolinks doesn't just give you some of the benefits of a single-page app. Turbolinks is a single page app. Think about it: When someone visits your site, you serve them some HTML and Javascript. The JavaScript takes over and manages all subsequent changes to the DOM. If that's not a single-page app, I don't know what is.

Our app is mostly about displaying pages of static information. We crunch a lot of data to generate a single error report page.

Honeybadger isn't a single page app, and it probably won't ever be. SPAs just don't make sense for our technical requirements.

Flexbox's strength is in its content-driven model. It doesn't need to know the content up-front. You can distribute items based on their content, allow boxes to wrap which is really handy for responsive design, you can even control the distribution of negative space separately to positive space.

Flexbox is for one dimensional layout (row or column). CSS grid is for two dimensional layout.

There is one situation where iframes are (almost) required: when the contents of the iframe is in a different domain, and you have to perform authentication or check cookies that are bound to that domain. It actually prevents security problems instead of creating them. For example, if you're writing a kind of plugin that can be used on any website, but the plugin has to authenticate on another domain, you could create a seamless iframe that runs and authenticates on the external domain.

I normally try to figure out if that's a good solution for the problem before resorting to iframes. Sometimes, however, an iframe just does the job better. It maintains its own browser history, helps you segregate CSS styles if that's an issue with the content you're loading in.

Usually, if you can do it without an iframe, that is a better option. I'm sure others here may have more information or more specific examples, it all comes down to the problem you are trying to solve.

Slackmojis is made by some random dude in Brooklyn. He doesn't work for Slack, isn't paid by Slack, he just thinks Slack is pretty cool. Super Official Lawyer Talk: Slackmojis is not created by, affiliated with, or supported by Slack Technologies, Inc.

The code is far simpler and easier to understand/verify

Ubuntu also supports ‘snap’ packages which are more suited for third-party applications and tools which evolve at their own speed, independently of Ubuntu. If you want to install a high-profile app like Skype or a toolchain like the latest version of Golang, you probably want the snap because it will give you fresher versions and more control of the specific major versions you want to track.

if it's not broken, fix it until it is.

If components gain the slot attribute, then it would be possible to implement the proposed behavior of <svelte:fragment /> by creating a component that has a default slot with out any wrappers. However, I think it's still a good idea to add <svelte:fragment /> so everyone who encounters this common use case doesn't have to come up with their own slightly different solutions.

Depending on what other component libraries you’ve used, you may be used to handling events by passing callback functions to component properties, or using a special event syntax – Svelte supports both, though one is usually more appropriate than the other depending on your situation. This post explains both ways.

Think first: why do you want to use it in the browser? Remember, servers must never trust browsers. You can't sanitize HTML for saving on the server anywhere else but on the server.

When there are imperfections, we rely on users and our active community to tell us how the software is not working correctly, so we can fix it. The way we do that, and have done for 15 years now, is via bug reports. Discussion is great, but detailed bug reports are better for letting developers know what’s wrong.

They may skim books for what they’ll “need to know.” They’re less likely to wonder, say, “How can we be sure that’s true?” than to ask “Is this going to be on the test?”

Nodes A wave function node occurs at points where the wave function is zero and changes signs. The electron has zero probability of being located at a node.

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

Maybe something more neutral just meaning a virtual element / no-element container would better express the intention? And regarding the syntax, maybe it would also feel less repetitive / boilerplaty than <svelte:slot slot="name" />... Maybe something like <svelte:fragment slot="name"> or <svelte:virtual slot="name">?

more leading edge than bleeding

Is using bleeding edge tech risky and foolish? How much blood are we talking about? My experience tells me Svelte is a safe choice, more leading edge than bleeding.

Magnetic materials are always made of metal, but not all metals are magnetic

If only Santa Anna had not repealed the Constitution of 1824. If only Santa Anna had not dissolved the legislatures. If only Santa Anna had not killed every Texan prisoner. If only Santa Anna had not gone to sleep without posting a guard at San Jacinto. If only Santa Anna had done any of these things Texas would probably still be a Mexican state; however, Santa Anna did none of these things. In fact it was his failure to do any of these things that caused Texas to become an independent republic.

At first Santa Anna's policy of execution carried the desired effect; all the Texans ran toward the American border (see map). However, his policy backfired. All the weak hearted Texan soldiers quit the army leaving only the hard core men.

These are sequential because build:ssr imports the public/index.html that build:dom produces.

I wouldn't use Flutter for web, mobile is good though.

It's super promising for web apps, just maybe not for web pages. I went from React to Svelte to Flutter for my current app project, and every step felt like a major upgrade.Flutter provides the best developer experience bar none, and I think it also has the potential to provide the best user experience. But probably only for PWAs, which users are likely to install anyway. Or other self-contained experiences, like Facebook games. It does have some Flash vibes, but is far more suitable for proper app development than Flash ever was while still feeling more like a normal website to the average user. It won't be the right choice for everything, but I believe it will be for a lot of things.

Fallback values aren't used to fix the browser compatibility. If the browser doesn't support CSS custom Properties, the fallback value won't help.

Secondary buttons are the ‘go back’ to the primary button’s ‘next’, or the ‘cancel’ button to the ‘submit’ button

I hope @hperrin you're still alive to discuss about this and eventually for a pull request.

After i've stabilized the library i can start to discuss about adding new components and features!

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

@monkeythedev I am curious how do you "organize" your work - You forked https://github.com/hperrin/svelte-material-ui and https://github.com/hperrin/svelte-material-ui is not very active. Do you plan an independent project ? I hope the original author would return at some times, if not, i'll see

Maybe @hperrin would be able to make an appearance and select a few additional maintainers to help out.

passive: true instructs chrome that no body will call e.preventDefault() so chrome can optimized scrolling just because no body will call e.preventDefault and so there is no need to wait listeners...

Who’s Using Snowpack?

If everyone did this, the repair shops would be out of business.

Used by folks at

This module should not be used in other npm modules since it modifies the default require behavior! It is designed to be used for development of final projects i.e. web-sites, applications etc.

Alexanderproposeshomesandofficesbedesignedandbuiltbytheireventualoccupants.Thesepeople,hereasons,knowbesttheirrequirementsforaparticularstructure.Weagree,andmakethesameargumentforcomputerprograms.Computerusersshouldwritetheirownprograms.KentBeck&WardCunningham,1987 [7]

Connected to this are Andy Matuschak’s comments about contextual backlinks bootstrapping new concepts before explicit definitions come into play.

Easily updated pages: don’t worry about precisely naming something at first. Let the meaning emerge over time and easily change it (propagating through all references).

Cognitive Overhead (aka Cognitive Load): often the task of specifying formalism is extraneous to the primary task, or is just plain annoying to do.

The basic intuition is described well by the Shipman & Marshall paper: users enter information in a mostly informal fashion, and then formalize only later in the task when appropriate formalisms become clear and also (more) immediately useful.

It’s important to notice something about these examples of synthesis representations: they go quite a bit further than simply grouping or associating things (though that is an important start). They have some kind of formal semantic structure (otherwise known as formality) that specifies what entities exist, and what kinds of relations exist between the entities. This formal structure isn’t just for show: it’s what enables the kind of synthesis that really powers significant knowledge work! Formal structures unlock powerful forms of reasoning like conceptual combination, analogy, and causal reasoning.

Systems which display backlinks to a node permit a new behavior: you can define a new node extensionally (rather than intensionally) by simply linking to it from many other nodes—even before it has any content.

This is the real issue here, and it's a bug with chrome devtools, fixed in Chrome 46.

I think it would be much better to whitelist registries

The meaning of the word "modularity" can vary somewhat based on context. The following are contextual examples of modularity across several fields of science, technology, industry, and culture:

In Rust, we use the "No New Rationale" rule, which says that the decision to merge (or not merge) an RFC is based only on rationale that was presented and debated in public. This avoids accidents where the community feels blindsided by a decision.

I'd like to go with an RFC-based governance model (similar to Rust, Ember or Swift) that looks something like this: new features go through a public RFC that describes the motivation for the change, a detailed implementation description, a description on how to document or teach the change (for kpm, that would roughly be focused around how it affected the usual workflows), any drawbacks or alternatives, and any open questions that should be addressed before merging. the change is discussed until all of the relevant arguments have been debated and the arguments are starting to become repetitive (they "reach a steady state") the RFC goes into "final comment period", allowing people who weren't paying close attention to every proposal to have a chance to weigh in with new arguments. assuming no new arguments are presented, the RFC is merged by consensus of the core team and the feature is implemented. All changes, regardless of their source, go through this process, giving active community members who aren't on the core team an opportunity to participate directly in the future direction of the project. (both because of proposals they submit and ones from the core team that they contribute to)

If nobody objects or can come up with improvements, I'll approve.

And the App will be responsible for display a list of users adding/removing users of said list

e annotations are visible to everyone both in the document itself and our public stream. Privat

Tell you why tree-shaking fails, if it does.

What it doesn't do

We expect a certain pattern when validate devtool name, pay attention and dont mix up the sequence of devtool string. The pattern is: [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map.

I've only done components that need to/can be Svelte-ified. For some things, like RTL and layout grid, you can just use the MDC packages.

will only apply up the chain

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

This is linux. Ouput first, formatting second. systemctl --no-pager -l should be the default.

Over 4 million people trust CloudApp

Retagging the HTML/CSS questions to use html-heading seems the right thing to do. For the other uses, I don't have enough grounding in the geographic area to know whether the direction and bearing are replacements for heading. But the tag information for heading should be created and should firmly point at the other tags — at least until it is expunged.

We could broadcast a warning if we find the variable to be set in the environment, but that is more likely than not to annoy people who intentionally set it.

If you have a better/simpler/"more official" solution, I'd still love to see it!

You may want to execute validations in a given specific order (this can be tricky especially when you have got asynchronous validations).