The Annotations API is an extension to the Europeana REST API which allows you to create, retrieve and manage annotations on Europeana objects. Annotations are user-contributed or system-generated enhancements, additions or corrections to (or a selection of) metadata or media. We adopted the Web Annotation Data Model as a base model for the representation of annotations and as a format for exchanging annotations between client applications and the API, but also the Web Annotation Protocol as base HTTP protocol for the API.

{
  "@context": “http://www.w3.org/ns/anno.jsonld”
  "id": "http://data.europeana.eu/annotations/1",
  "type": "Annotation",
  "created": "2015-03-10T14:08:07Z",
  "creator": {
    "type": "Person",
    "name": "John Smith"
  },
  "generated": "2015-04-01T09:00:00Z",
  "generator": {
      "type": "Software",
      "name": "HistoryPin",
      "homepage": "https://www.historypin.org/"
  },
  "motivation": "tagging",
  "bodyValue": "MyBeautifulTag",
  "target": "http://data.europeana.eu/item/92062/BibliographicResource_1000126189360"
}

Sit in your local coffee shop, and your laptop can tell you a lot. If you want deeper, more local knowledge, you will have to take the narrower path that leads between the lions and up the stairs.

The databases include multiple copies of some titles. But they will never provide all the copies of, say, “The Wealth of Nations” and the early responses it provoked.

how to create, access, make available, re-use, adapt, and redistribute OER

libraries

Deeply importing Svelte components is not supported. Either import all components from one entrypoint, or always stick to deep imports, otherwise it could cause multiple instance of the Svelte library running.

A good library is filled with mostly unread books. That’s the point. Our relationship with the unknown causes the very problem Taleb is famous for contextualizing: the black swan. Because we underestimate the value of what we don’t know and overvalue what we do know, we fundamentally misunderstand the likelihood of surprises. The antidote to this overconfidence boils down to our relationship with knowledge. The anti-scholar, as Taleb refers to it, is “someone who focuses on the unread books, and makes an attempt not to treat his knowledge as a treasure, or even a possession, or even a self-esteem enhancement device — a skeptical empiricist.” My library serves as a visual reminder of what I don’t know.

Its good to know how to implement it. I would prefer to use a gem myself.

copyright and open licensing of educational material

The usual targets of The Publishers Association include domains that facilitate access to the popular Libgen library and eBook portals eBookee and FreeBookSpot. The trend was maintained this week when ISP TalkTalk revealed that more domains had been blocked in the UK. The new additions are as follows: ebookee.unblockit.kim, ebookee.123unblock.world, ebookee.mrunblock.bar, ebookee.nocensor.biz, ebookee.unbl4you.cyou, ebookee.unbl0ck.icu, ebookee.unblockproject.top, ebookee.proxybit.sbs, freebookspot.unblockit.kim, libgen.unblockit.kim, libgen.123unblock.world, libgen.mrunblock.bar, libgen.nocensor.biz, libgen.unbl4you.cyou,, libgen.unbl0ck.icu, libgen.unblockproject.top, libgen.proxybit.sbs

you can define locally parse and it should take precedence over the one in the library: interface JSON { parse(text: string, reviver?: (key: any, value: any) => any): unknown; }

we establish Saturated Programmable Insertion Engineering (SPINE), an unbiased, comprehensive, and targeted domain insertion library generation technique using oligo library synthesis and multi-step Golden Gate cloning

If you fail to changes this, you may experience performance issues, and other bugs related to multiple copies of React, like issue 2932.

In the vast majority of cases when I'm using prettier-ignore I'm only really looking to prevent it from breaking my code into new lines, whilst keeping its other transformations such as switching quotes and adding space between brackets. When ignoring single lines, fixing these formatting problems by hand is very manageable. With the ability to have Prettier ignore entire blocks of code I think the ability to specify what you want it to ignore is essential.

This should be basic functionality.

I have a rule that I won't allow Capybara to be monkey-patched in Poltergeist. This gives some indication to users about whether something is non-standard. So basically all non-standard stuff must be on page.driver rather than page (or a node).

I think that it's nonsense not to have a method that just gives -1 or +1. Even BASIC has such a function SGN(n). Why should we have to deal with Strings when it's numbers we want to work with. But's that's just MHO.

As Jorge Luis Borges pointed out, a library without an index becomes paradoxically less informative as it grows.

Gottfried Wilhelm Leibniz (1646-1716), der nicht nur angesehener Mathematiker und Philosoph war, sondern auch Bibliothekar der Herzog August Bibliothek in Wolfenbüttel, soll sich eigens einen Karteischrank als Büchermöbel nach eigenen Vorstellungen haben bauen lassen.

The Joke File has been scanned into an internal database that is accessible on-site in both the Recorded Sound and Moving Image Research Centers.

But if you're working on a bigger project, with multiple packages and a complex dependency tree, you might want to combine npm with a tool like Lerna.

AnyCable uses the same protocol as ActionCable, so you can use its JavaScript client without any monkey-patching.

This is why for a recent Angular+Rails project we chose to use a testing stack from the backend technology’s ecosystem for e2e testing.

We used testing tools that were in the same ecosystem as our backend technology stack for primrily three reasons: We owned both ends of the stack Team experience Interacting with the database

We chose to define the frontend in one technology stack (Angular+TypeScript/JavaScript) and the backend in another (Ruby+Ruby on Rails), but both came together to fulfill a singular product vision.

Note: as for setting boolean variables: not only are true/false and 0/1 acceptable values, but also T/F and on/off. Thanks, coercible!

Do not test the internal implementation of the child components:

Don’t test the library

Testing the hasMetricTypes computed prop would seem like a given here. But to test if the computed property is returning the length of metricTypes, is testing the Vue library itself. There is no value in this, besides it adding to the test suite.

Or if you're looking for a core extension that adds this to the Array class, I'd recommend the facets gem (require 'facets/array/average'). Then you can just do array.average. And, from looking at the source, it turns out they do the exact same thing as the instance_eval approach above. The only difference is that it's implemented as a method—which of course already has self pointing to itself—instead of a block): def average; return nil if empty?; reduce(:+) / length.to_f; end Main advantage of this is that it's even more concise/readable and it handles the empty? case.

The great library of Alexandria, which began around 300 B.C.E., created a cataloguing system called Pinakes to manage the estimated 500,000 books in the collection of the Ptolemaic pharaohs. The Pinakes were sophisticated bibliographical lists containing title, incipit (the first few lines of each text), the number of lines for each work, and a subject and author index.

In fact, I'm only here because it seems like something one would 'expect' ruby already to do.

but I like that Svelte comes with a good CSS story out the box.

Svelte is different in that by default most of your code is only going to run once; a console.log('foo') line in a component will only run when that component is first rendered.

I ended up renting an ebook version for more money than I should have had to pay to buy the thing, which is my darn fault because I wanted quick access

The Law of Innocence

No. 6 collaborations project [sound recording]

he goes on to talk about third party problems and how you're never guaranteed something is written correctly or that even if it is you don't know if it's the most optimal solution

this only applies to end products which are actually deployed. For my modules, I try to keep dependency version ranges at defaults, and recommend others do the same. All this pinning and packing is really the responsibility of the last user in the chain, and from experience, you will make their life significantly more difficult if you pin your own module dependencies.

The question, 'What is library and information science?' does not elicit responses of the same internal conceptual coherence as similar inquiries as to the nature of other fields, e.g., 'What is chemistry?', 'What is economics?', 'What is medicine?' Each of those fields, though broad in scope, has clear ties to basic concerns of their field. [...] Neither LIS theory nor practice is perceived to be monolithic nor unified by a common literature or set of professional skills. Occasionally, LIS scholars (many of whom do not self-identify as members of an interreading LIS community, or prefer names other than LIS), attempt, but are unable, to find core concepts in common

Some believe that computing and internetworking concepts and skills underlie virtually every important aspect of LIS, indeed see LIS as a sub-field of computer science!

This allows those other dependencies to share the same module instance.

URI::MailTo::EMAIL_REGEXP

While you could nest an activity into another manually, the Subprocess macro will come in handy.

The macro automatically wires all of Validate’s ends to the known counter-part tracks.

Have you ever felt like a framework was getting in the way instead of helping you go faster? Maybe you’re stuck on some simple task that would be easy to do manually, but your framework is making you jump through configuration hoops. I end up getting lost in a sea of documentation (or no documentation), and the search for that one magical config key takes just a tad bit too long. It’s a productivity sink, and worse than the time delay it adds to my frustration throughout the day.

Trailblazer is an architectural pattern that comes with Ruby libraries to implement that pattern.

ActiveModel provides a powerful framework for defining callbacks. ActiveInteraction hooks into that framework to allow hooking into various parts of an interaction's lifecycle.

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.

No one has requested it before so it's certainly not something we're planning to add.

To give a little more context, structures like this often come up in my work when dealing with NoSQL datastores, especially ones that rely heavily on JSON, like Firebase, where a records unique ID isn't part of the record itself, just a key that points to it. I think most Ruby/Rails projects tend towards use cases where these sort of datastores aren't appropriate/necessary, so it makes sense that this wouldn't come up as quickly as other structures.

Writing the uniqueness validations yourself is easy so I felt it was better to leave this up to the developer

The "authority terms" comprising it are expected to be used outside the library catalog, as metadata in the sources, enabling links to the taxonomy.

Now if you think about it, PJAX sounds a lot like Turbolinks. They both use JS to fetch server-rendered HTML and put it into the DOM. They both do caching and manage the forward and back buttons. It's almost as if the Rails team took a technique developed elsewhere and just rebranded it.

Increasing student motivation and the perception of chemistry's relevance in the classroom by learning about tattooing from a chemical and societal view

From Cookbook to Research: Redesigning an Advanced Biochemistry Laboratory

Chemistry outreach as a community of practice: investigating the relationship between student-facilitators’ experiences and boundary processes in a student-run organization

The relationship between subject matter knowledge and teaching effectiveness of undergraduate chemistry peer facilitators

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.

Popper for Svelte with actions, no wrapper components or component bindings required! Other Popper libraries for Svelte (including the official @popperjs/svelte library) use a wrapper component that takes the required DOM elements as props. Not only does this require multiple bind:this, you also have to pollute your script tag with multiple DOM references. We can do better with Svelte actions!

Biosciences Robert Sabin 713-348-4324 Charles Stewart

If you'd prefer, you can use a third-party library like Modernizr or Detect It to do this test for you.

Sometimes, systems just scale the problemA UI design system is more than the code of a component library. It’s more than the colors, styles, and margins of your elements. It’s an ever-growing and ever-evolving creature that entails your brand and your user’s feelings.

I also find that a lot of the complexity of Flutter can be avoided, and I mostly use it to define the UI as a more app-centric alternative to HTML/CSS.

As was mentioned in the comments above, the material design spec for buttons specifies that the text should be uppercase, but you can easily override its CSS property: paper-button { text-transform: none; }

@use "@material/theme" with (  $primary: #FEDBD0,  $on-primary: #442C2E);

The ultimate goal of the Open Library is to make all the published works of humankind available to everyone in the world. While large in scope and ambition, this goal is within our grasp.

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.

Is there any service that does this sort of alert when my library gets a book I want?

The resolve.alias option is used to make sure that only one copy of the Svelte runtime is bundled in the app, even if you are npm linking in dependencies with their own copy of the svelte package. Having multiple copies of the internal scheduler in an app, besides being inefficient, can also cause various problems.

Just coming here to voice my agreement that these warnings are annoying and exist in other libraries as well. For me this happened with svelma. I didn't write the library code, so I don't have complete control over it even though I agree there is an argument to be had around whether I should be notified anyway. In either case, these warnings should be easily disabled since libraries don't always get updated over night.

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

I would like the compiler to add a property like canIgnore: false to the warning, if the warning cannot be disabled.

In principle, this information is already available through other means, but it is actually a fair amount of work to gather it in this form, and I think it could be useful to open it up to programmatic consumption.

Focus on your application: forget about forms details like I'm dirty, field touched...

Form Validation

return { type: "COUNTRY_BLACK_LIST", succeeded, message: succeeded ? "" : "This country is not available" }

It is easily extensible (already implemented Final Form and Formik plugin extensions).

You can try to build a solution to tackle these issues on your own, but it will cost you time and money... why not use a battle-tested solution to handle all this complexity?

If you want to implement a form with a superb User Experience, you have to take care of many variables:

Form validation can get complex (synchronous validations, asynchronous validations, record validations, field validations, internationalization, schemas definitions...). To cope with these challenges we will leverage this into Fonk and Fonk Final Form adaptor for a React Final Form seamless integration.

Managing Form State (holding field information, check if a control has been touched, if the user has clicked the submit button, who owns the current focus...) can be tedious and prone to errors. We can get help from React Final Form to handle these challenges for us.

Fonk is framework extension, and can be easily plugged into many libraries / frameworks, in this documentation you will find integrations with:

Vue Final Form A form state management system for Vue that uses Final Form under the hood.

But it sounds like the library could use some way to setTouched()