It can be useful to use with keywords argument, which required symbol keys.

Der österreichische Energieverbrauch beträgt zirka 404 TWh (1 Terawattstunde = 1012 Wattstunden) und steigt jährlich um mehr als 2 %. Etwa 25 % davon stammen aus erneuerbaren Energiequellen. Eine grobe Betrachtung zeigt, dass etwa je ein Drittel des Energieverbrauchs auf Verkehr, Industrie und andere Verbraucher entfällt. Ein Anteil von etwa 60 TWh wird in der Form von elektrischer Energie verbraucht. Durch die günstigen natürlichen Gegebenheiten in Österreich können etwa 60 % davon aus Wasserkraft gewonnen werden. Auf Grund des stetig steigenden Verbrauchs und in geringerem Ausmaß wegen der Liberalisierung der Strommärkte erzeugt Österreich seit dem Ende der 90-er Jahre auch bei der Elektrizität nicht mehr selbst seinen Eigenbedarf. Im europäischen Vergleich hat Österreich - vor allem auf Grund der Wasserkraft - einen hohen Anteil an erneuerbarer Energie. In Europa erfolgt die Stromgewinnung zu etwa 85 % aus fossilen Rohstoffen sowie Kernenergie und zu 15 % aus erneuerbaren Quellen. Es ist also derzeit in allen Bereichen eine überwiegende Abhängigkeit von fossilen Energieträgern gegeben.

Once you have collected and summarized the information, it’s time to highlight some key elements. Include index information like the author’s name, book location, or the link URL. For longer Zettels, highlighting the learning objectives or key points in a bullet list might be helpful. The main point is to write your notes in such a way that you will easily be able to quickly get the gist of the material when you come across it again.

Step 1: Read and take smart notes When working, write down your thoughts and the reason why you are taking particular note of a piece of information. This way, you will better understand the focus and reasoning behind the information you jot down. Even better, summarize the information and write it in your own words as much as you can.

Permanent notes are stand-alone ideas that can be made without any direct context to other sourced information such as books, videos, or other available data.   Permanent notes can be made as a recap or summary of the information just researched or learned, but can also be thoughts that popped into your brain while thinking over a myriad of information or while analysing any given context. The aim of permanent notes is to process the notes you have made and analyze how they affect your interests, thinking, and research. You then cherry pick the notes that add value to your existing ideas and connect the new information to what you already know and have saved in your database.

The technique of grouping information, organizing ideas into categories, and creating tags to help you find grouped information at a later stage is the art of reference notes. When we reference something, it is safe to say that the topic or idea we are writing about is part of a bigger topic or is information accredited to someone or someplace else. We use this technique in various daily circumstances and the function is available on almost every software and app available today. 

The Zettelkasten method is good for when you want to: Systematically organize important information Find information again, even years later Develop your own ideas

Not trying to be presumptuous, but thought this proposal would be best served with a PR.

I have been doing different things w/ Ruby for a couple of years now and the only bad thing I can say about it is that it makes programming in other languages feel awfully burdensome. = )

For example, if I make an application (Client) that allows a user (Resource Owner) to make notes and save them as a repo in their GitHub account (Resource Server), then my application will need to access their GitHub data. It's not secure for the user to directly supply their GitHub username and password to my application and grant full access to the entire account. Instead, using OAuth 2.0, they can go through an authorization flow that will grant limited access to some resources based on a scope, and I will never have access to any other data or their password.

session = ActionDispatch::Integration::Session.new(Rails.application) response = session.post("/mypath", my_params: "go_here")

I used the above to test what happens to the user if a POST happens in another session (via WebSockets), so a form wouldn't cut it.

The uses of flow diagrams are vast and honestly endless.

There are two situations where an init-like process would be helpful for the container.

highly recommended that the resulting image be just one concern per container; predominantly this means just one process per container, so there is no need for a full init system

As to whether you should be using Tini.

Unless you are the maintainer of lvh.me, you can not be sure it will not disappear or change its RRs for lvh.me. You can use localhost.localdomain instead of localhost, by adding the following lines in your hosts file: 127.0.0.1 localhost localhost.localdomain ::1 localhost localhost.localdomain This is better than using lvh.me because: you may not always have access to a DNS resolver, when developing

They were adding social structures and context to the data. Basically adding social software design principles to a large volume of data.

they had given a number of their professionals access to their business intelligence data. Because they were gathering so much data nobody really looked at for lack of good questions to ask of the dataset. The professionals put the data to good use, because they could formulate the right questions.

Consumers can use the status member to determine what the original status code used by the generator was, in cases where it has been changed (e.g., by an intermediary or cache), and when message bodies persist without HTTP information. Generic HTTP software will still use the HTTP status code.

Literacies Teachers Need During Covid-19

unevaluatedProperties is like additionalProperties, except that it can "see through" $ref and "see inside" allOf, anyOf, oneOf, if, then, else

my use of the schema would have nothing to do with validation but generating typescript definition and having more accurate code editor completion/suggestions.

One of the reasons I initially pushed back on the creation of a JSON Schema for V3 is because I feared that people would try to use it as a document validator. However, I was convinced by other TSC members that there were valid uses of a schema beyond validation.

I'm not sure if there's a reason why additionalProperties only looks at the sibling-level when checking allowed properties but IMHO this should be changed.

It's unfortunate that additionalProperties only takes the immediate, sibling-level properties into account

additionalProperties applies to all properties that are not accounted-for by properties or patternProperties in the immediate schema.

additionalProperties here applies to all properties, because there is no sibling-level properties entry - the one inside allOf does not count.

What I want is to use "additionalProperties: false" to validate a union of schemas, but it seems it isn't possible. I already tried with sevaral different combination, but I didn't make it works.

additionalProperties: false works on it, but not along with allOf, because only validate one schema or another.

While libraries pay substantial fees to OCLC and other providers for services including deduplication, discovery, and enhancement, they do not do so with the intent that their records should then be siloed or restricted from re-use. Regardless of who has contributed to descriptive records, individual records are generally not copyrightable, nor is it in the public interest for their use to be restricted.

You can use Danger to codify your team's norms, leaving humans to think about harder problems.

The moral is not to abandon useful tools; rather, it is, first, that one shouldmaintain enough perspective to be able to detect the arrival of that inevitable daywhen the research that can be conducted with these tools is no longer important;

This is a living document. Ideas or feedback can be contributed through commenting directly using Hypothes.is which will create issues in the Github repo or you can directly create an issue: https://github.com/FAIRIslandProject/Generic-Place-based-Data-Policy/issues

The potential for digital technology to support learners in this process was highlighted in the studies reviewed, but commonly learners lacked the competence to use digital technologies for educational purposes. Learners often required support, especially with the planning and reviewing aspects of self-directed learning, as well as guidance regarding how digital technologies can be used effectively for educational purposes. Importantly, studies that focus on understanding the facilitation of self-directed learning in childhood education are seldom. Further studies on self-directed learning in childhood education are vital – given that this is a fundamental competence for preparing our youth to deal with work and life in our rapidly changing world.

focused on the language that the children used when they were involved in a design and technology activity

Jake Fiennes, the head of conservation at the Holkham estate in Norfolk and author of nature-friendly farming book Land Healer, said he was unsurprised by the results of the report

10-year project by the UK Centre for Ecology and Hydrology revealed that nature-friendly farming methods boost biodiversity without reducing average yield

Beyond memory leaks, it's also really useful to be able to re-run a test many times to help with tracking down intermittence failure and race conditions.

Since they are already using the Node toolchain for the front-end, developers from this track only needed to stretch a bit more to become “full-stack” engineers.

5.9 Use principles.

2 Use the 5-Step Process to Get What You Want Out of Life

Thinking clearly about technological progress versus technological hype requires us to consider the question of why people buy and adopt new technologies in general. A type of academic analysis called the technology acceptance model identifies two notable factors: perceived ease of use and perceived usefulness. That is, we embrace new technologies when they seem easy enough to use and when we believe they will help us do something worthwhile.

Chapter 5: Demand, services and social aspects of mitigation

Google Library: Beyond Fair Use?

Google's use of thumbnail images in its Image. Search is fair and noninfringing

The nature-of-work factor generally focuses on the degree of expressiveness of the plaintiff's work. Artistic and fanciful works tend to be highly expressive, so it is generally more difficult to win fair use defenses involving such works. Fact-intensive and highly functional works tend, by contrast, to have a lesser quantum of expressive content. Hence, fair use may be easier to establish in cases involving such works.

We write on behalf of plaintiffs Hachette Book Group, Inc., HarperCollins PublishersLLC, John Wiley & Sons, Inc. and Penguin Random House LLC (the “Plaintiffs”) to request apre-motion summary judgment conference pursuant to Individual Practice 2(B).

The intent of this specification and related tools is to expand the reach of development containers, allow the usage of containers by themselves or different orchestration technologies, and allow any tool to manage and create them.

The focus of the dev container specification is to describe how to enrich a container for the purposes of development, rather than acting as a multi-container orchestrator format.

I write on behalf of Defendant Internet Archive pursuant to Paragraph 2-B of Your Honor’s IndividualPractices to request a pre-motion conference on a motion for summary judgment in the above matter.

The shared context worked though thanks! RSpec.shared_context "perform_enqueued_jobs" do around(:each) { |example| perform_enqueued_jobs { example.run } } end RSpec.configure do |config| config.include_context "perform_enqueued_jobs" end

1/ It fits into existing spec based testing infrastructure nicely, including running on travis, code coverage using SimpleCov, switching between generating a profile (RubyProf), a benchmark (Benchmark::IPS) or normal test run. 2/ Some of my benchmarks do have expect clauses to validate that things are working before invoking the benchmark.

I just wanted to mention there was, IMHO, a valid use case for this. It helps add to the validity of the ticket and the design of the feature.

It really looks like a few lines of code — https://github.com/seanwalbran/rspec_around_all/blob/master/lib/rspec_around_all.rb — which complete the DSL and make up for those 0.1% of the cases like mine.

I’m gonna use Node!

According to a Pew study from last year, only 20 percent of K-12 students in America study a foreign language (compared with an average of 92 percent in Europe), and only 10 states and the District of Columbia make foreign-language learning a high school graduation requirement.

According to the Modern Language Association, enrollment in college-level foreign-language courses dropped 9.2 percent from 2013 to 2016.

To run it you need node.js installed, and from the command line run npm install once inside that directory to install the library dependencies. Then node run.js <yourExportedDirectory>

Here’s a super rough proof of concept Replit tiny library.

Instead read this gems brief source code completely before use OR copy the code straight into your codebase.

Let's imagine your project talks to databases, supports several, and has adapters for each one of them. Those adapters may have top-level require calls that load their respective drivers: # my_gem/db_adapters/postgresql.rb require "pg" but you don't want your users to install them all, only the one they are going to use.

There are project layouts that put implementation files and test files together.

Let's suppose that your gem decorates something in Kernel:

if Rails.application.config.reloading_enabled? Rails.autoloaders.main.on_unload("Country") do |klass, _abspath| klass.expire_redis_cache end end

If your application decorates classes or modules from an engine,

Some projects want something like app/api/base.rb to define API::Base, and add app to the autoload paths to accomplish that.

By default, app/models/concerns belongs to the autoload paths and therefore it is assumed to be a root directory. So, by default, app/models/concerns/foo.rb should define Foo, not Concerns::Foo.

It feels great to get an email from someone you care about. Or a newsletter you enjoy. Or an update from a service you like. That’s how email used to feel all the time.

Now email feels like a chore, rather than a joy. Something you fall behind on. Something you clear out, not cherish. Rather than delight in it, you deal with it.

HEY’s fresh approach transforms email into something you want to use, not something you’re forced to deal with.

(I can't imagine use case for it but if you can, please open a pull request or issue).

I am not looking for model based after commits on update/create/etc, I want to be able to dynamically define a block that will be executed only if the current (top-most) transaction passes:

This would work if your transaction only wraps a single model's save operation. I need to wrap at least Node + Version + Attachment

You want the front page to show a few hundred posts along with the top three comments on each post. You’re planning on being very popular, so the front page will need to be very fast. How do you fetch that data efficiently from postgresql using Activerecord?

Making one Comment query per Post is too expensive; it’s N+1 queries (one to fetch the posts, N to fetch the comments). You could use includes to preload all the comments for all the posts, but that requires hydrating hundreds of thousands of records, even though you only need a few hundred for your front page. What you want is some kind of GROUP BY with a LIMIT on each group — but that doesn’t exist, either in Activerecord nor even in postgres. Postgres has a different solution for this problem: the LATERAL JOIN.

3. Who are you annotating with? Learning usually needs a certain degree of protection, a safe space. Groups can provide that, but public space often less so. In Hypothes.is who are you annotating with? Everybody? Specific groups of learners? Just yourself and one or two others? All of that, depending on the text you’re annotating? How granular is your control over the sharing with groups, so that you can choose your level of learning safety?

Tools like Hypothes.is are designed as silos to ensure that its social features work.

Let's say the user is in the process of selecting some files. The names don't indicate anything. So she has to listen and select.

When a web page is viewed on a screen with a large physical size (assuming a maximised browser window), the author might wish to include some less relevant parts surrounding the critical part of the image. When the same web page is viewed on a screen with a small physical size, the author might wish to show only the critical part of the image.

This has cropped up in particular when trying to create a copy of a store object when the store changes (which is a common use case with forms where you don't want to mutate the global store until the form is saved).

This is particularly useful in cases where you want to separate your data migrations from your schema migrations or where you have multiple steps in your migration process that must have other steps invoked throughout.

There are a couple of reasons why you may want to do this.

If you need to ensure migrations run in a certain order with regular db:migrate, set up Outrigger.ordered. It can be a hash or a proc that takes a tag; either way it needs to return a sortable value: Outrigger.ordered = { predeploy: -1, postdeploy: 1 } This will run predeploys, untagged migrations (implicitly 0), and then postdeploy migrations.

class PreDeployMigration < ActiveRecord::Migration tag :predeploy end

This is especially useful for zero downtime deploys to Production environments.

En somme, les études sur la communication des élèves atteints d’autisme permettent de mettre en évidence l’importance d’un contexte riche en stimulations appropriées (sons et images), mais également une évidente « stabilité » de l’information à décoder, le suivi des émotions des personnages, le rôle de l’imitation dans les apprentissages. Ces résultats encouragent donc l’usage d’outils informatiques adéquats pour améliorer la communication sociale chez les enfants atteints d’autisme.

Nous allons montrer par une courte analyse de quelques études l’impact du travail éducatif informatisé dans l’apprentissage de la communication sociale chez des enfants atteints d’autisme.

Google Hangouts

Glogster Edu

Voki

Google Sites

Adobe Spark in the Classroom

This tool requires Node

Screening is a useful way of avoiding spam and/or other unwanted correspondence.

Filing is the simplest application to take advantage of plus signs.

Currently you need to have Node and npm installed on your machine once this is done you can use it with the following command

This is especially useful for UI library components, as it is generally unknown which events will be required from them for all desired use cases. For example, if a Button component only forwards a click event, then no use case that requires the mouseover or the keypress event can be used with it.

This is a widespread mistake among those who think that a sexy note-taking app like Roam will suddenly free their minds, or that they can train themselves into geniuses with enough spaced repetition, or that they can build a zettelkasten capable of thinking original thoughts for them.

people want to have an object, lets call it a Product that they want to create in several different steps

“ Reports of the destruction of books in transport from Lilienfeld in 1789 are well known. At that time, books were used by the coachmen to patch bad roads. ”

Companies should not assume they can release a product without thinking about its unintended uses and then undo the harm that results. This often doesn’t work.Some technology