The aim of this list is to document all Markdown syntax variations (rather than implementations).

Devise-Two-Factor only worries about the backend, leaving the details of the integration up to you. This means that you're responsible for building the UI that drives the gem. While there is an example Rails application included in the gem, it is important to remember that this gem is intentionally very open-ended, and you should build a user experience which fits your individual application.

public money isnot used to create or perpetuate disability-related barriers, and regarding training of front-linepersonnel.

it doesn't even render in-file components. For example, the <Fade /> component we have above is an implementation detail of the <HiddenMessage /> component, but because we're shallow rendering <Fade /> isn't rendered so changes to that component could break our application but not our test. That's a major issue in my mind and is evidence to me that we're testing implementation details.

The reason this kind of test fails those considerations is because it's testing irrelevant implementation details. The user doesn't care one bit what things are called. In fact, that test doesn't even verify that the message is hidden properly when the show state is false or shown when the show state is true. So not only does the test not do a great job keeping us safe from breakages, it's also flakey and doesn't actually test the reason the component exists in the first place.

I could rename toggle to handleButtonClick (and update the corresponding onClick reference). My test breaks despite this being a refactor.

I could mistakenly set onClick of the button to this.tgogle instead of this.toggle. My test continues to work, but my component is broken.

Will this test break when there's a mistake that would break the component in production?Will this test continue to work when there's a fully backward compatible refactor of the component?

Why is testing implementation details bad?There are two distinct reasons that it's important to avoid testing implementation details. Tests which test implementation details:Can break when you refactor application code. False negativesMay not fail when you break application code. False positives

But far too often, I see tests which are testing implementation details (read this before continuing if you haven't already). When you do this, you introduce a third user. The developer user and the end user are really all that matters for this component. So long as it serves those two, then it has a reason to exist. And when you're maintaining the component you need to keep those two users in mind to make sure that if you break the contract with them, you do something to handle that change.But as soon as you start testing things which your developer user and end user don't know or care about (implementation details), you add a third testing user, you're now having to keep that third user in your head and make sure you account for changes that affect the testing user as well.

You want to write maintainable tests for your React components. As a part of this goal, you want your tests to avoid including implementation details of your components and rather focus on making your tests give you the confidence for which they are intended. As part of this, you want your testbase to be maintainable in the long run so refactors of your components (changes to implementation but not functionality) don't break your tests and slow you and your team down.

At the heart of good teaching with technology are three core components: content, pedagogy, and technology, plus the relationships among and between them. The interactions between and among the three components, playing out differently across diverse contexts, account for the wide variations seen in the extent and quality of educational technology integration

offering humanity a way to address complex problems together

Kompetenzraster des Medienpasses

Zuordnungstabelle

At a time of once-in-a-generation reform to healthcare in this country, the leaders of HM can’t afford to rest on their laurels, says Dr. Goldman. Three years ago, he wrote a paper for the Journal of Hospital Medicine titled “An Intellectual Agenda for Hospitalists.” In short, Dr. Goldman would like to see hospitalists move more into advancing science themselves rather than implementing the scientific discoveries of others. He cautions anyone against taking that as criticism of the field. “If hospitalists are going to be the people who implement what other people have found, they run the risk of being the ones who make sure everybody gets perioperative beta-blockers even if they don’t really work,” he says. “If you want to take it to the illogical extreme, you could have people who were experts in how most efficiently to do bloodletting. “The future for hospitalists, if they’re going to get to the next level—I think they can and will—is that they have to be in the discovery zone as well as the implementation zone.” Dr. Wachter says it’s about staying ahead of the curve. For 20 years, the field has been on the cutting edge of how hospitals treat patients. To grow even more, it will be crucial to keep that focus.

By 2007, SHM had launched Project BOOST (Better Outcomes by Optimizing Safe Transitions), an award-winning mentored-implementation program to reduce LOS, adverse events, and unnecessary 30-day readmissions. Other mentored-implementation programs followed. The Glycemic Control Mentored Implementation (GCMI) program focuses on preventing hypoglycemia, while the Venous Thromboembolism Prevention Collaborative (VTE PC) seeks to give practical assistance on how to reduce blood clots via a VTE prevention program

“The ADDIE model consists of five steps: analysis, design, development, implementation, and evaluation. It is a strategic plan for course design and may serve as a blueprint to design IL assignments and various other instructional activities.”

In January of that year, the company began testing a tool called the web annotator, which allowed anyone to add genius.it/ before any URL and then highlight and annotate text.

MOOCs tend to attract those with already a high level of education, rather than widen access

approaches

an objective set for the Sprint that can be met through the implementation of Product Backlog. It provides guidance to the Development Team on why it is building the Increment. It is created during the Sprint Planning meeting. The Sprint Goal gives the Development Team some flexibility regarding the functionality implemented within the Sprint. The selected Product Backlog items deliver one coherent function, which can be the Sprint Goal. The Sprint Goal can be any other coherence that causes the Development Team to work together rather than on separate initiatives.

I regret that the documentation does not focus on what is most relevant; by focusing on a largely irrelevant implementation detail, we enlarge the importance of that implementation detail and obscure the importance of what makes a value type semantically useful. I dearly wish that all those articles explaining what “the stack” is would instead spend time explaining what exactly “copied by value” means and how misunderstanding or misusing “copy by value” can cause bugs.

I find this characterization of a value type based on its implementation details rather than its observable characteristics to be both confusing and unfortunate

Surely the most relevant fact about value types is not the implementation detail of how they are allocated, but rather the by-design semantic meaning of “value type”, namely that they are always copied “by value”.

I blogged a while back about how “references” are often described as “addresses” when describing the semantics of the C# memory model. Though that’s arguably correct, it’s also arguably an implementation detail rather than an important eternal truth. Another memory-model implementation detail I often see presented as a fact is “value types are allocated on the stack”. I often see it because of course, that’s what our documentation says.