[1m[36mDelayed::Backend::ActiveRecord::Job Load (77.1ms)[0m [1mUPDATE “delayed_jobs” SET locked_at = '2014-05-31 21:13:39.079329', locked_by = 'delayed_job.0 host:notebook pid:5367' WHERE id IN (SELECT “delayed_jobs”.“id” FROM “delayed_jobs” WHERE ((run_at <= '2014-05-31 21:13:39.060052' AND (locked_at IS NULL OR locked_at < '2014-05-31 17:13:39.060104') OR locked_by = 'delayed_job.0 host:notebook pid:5367') AND failed_at IS NULL) ORDER BY priority ASC, run_at ASC LIMIT 1 FOR UPDATE) RETURNING *[0m [1m[35mUniverso Load (0.2ms)[0m SELECT “universos”.* FROM “universos” WHERE “universos”.“id” = $1 LIMIT 1 [[“id”, 1]] [1m[36m (0.2ms)[0m [1mBEGIN[0m [1m[35mSQL (0.6ms)[0m UPDATE “delayed_jobs” SET “attempts” = $1, “last_error” = $2, “locked_at” = $3, “locked_by” = $4, “run_at” = $5, “updated_at” = $6 WHERE “delayed_jobs”.“id” = 1 [[“attempts”, 1], [“last_error”, “undefined method `configurar_without_delay!' for #<Universo:0x007f1defadfb60>n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/activemodel-4.1.1/lib/active_model/attribute_methods.rb:435:in `method_missing'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/activerecord-4.1.1/lib/active_record/attribute_methods.rb:206:in `method_missing'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/performable_method.rb:26:in `perform'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/backend/base.rb:105:in `block in invoke_job'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:60:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:60:in `block in initialize'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:65:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:65:in `execute'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:38:in `run_callbacks'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/backend/base.rb:102:in `invoke_job'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:207:in `block (2 levels) in run'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/2.1.0/timeout.rb:91:in `block in timeout'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/2.1.0/timeout.rb:101:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/2.1.0/timeout.rb:101:in `timeout'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:207:in `block in run'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/2.1.0/benchmark.rb:294:in `realtime'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:206:in `run'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:274:in `block in reserve_and_run_one_job'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:60:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:60:in `block in initialize'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:65:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:65:in `execute'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:38:in `run_callbacks'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:274:in `reserve_and_run_one_job'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:190:in `block in work_off'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:189:in `times'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:189:in `work_off'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:154:in `block (4 levels) in start'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/2.1.0/benchmark.rb:294:in `realtime'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:153:in `block (3 levels) in start'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:60:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:60:in `block in initialize'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:65:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:65:in `execute'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:38:in `run_callbacks'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:152:in `block (2 levels) in start'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:151:in `loop'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:151:in `block in start'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/plugins/clear_locks.rb:7:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/plugins/clear_locks.rb:7:in `block (2 levels) in <class:ClearLocks>'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:78:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:78:in `block (2 levels) in add'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:60:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:60:in `block in initialize'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:78:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:78:in `block in add'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:65:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:65:in `execute'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/lifecycle.rb:38:in `run_callbacks'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/worker.rb:150:in `start'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/command.rb:104:in `run'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/command.rb:92:in `block in run_process'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/daemons-1.1.9/lib/daemons/application.rb:255:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/daemons-1.1.9/lib/daemons/application.rb:255:in `block in start_proc'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/daemons-1.1.9/lib/daemons/daemonize.rb:82:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/daemons-1.1.9/lib/daemons/daemonize.rb:82:in `call_as_daemon'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/daemons-1.1.9/lib/daemons/application.rb:259:in `start_proc'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/daemons-1.1.9/lib/daemons/application.rb:296:in `start'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/daemons-1.1.9/lib/daemons/controller.rb:70:in `run'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/daemons-1.1.9/lib/daemons.rb:197:in `block in run_proc'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/daemons-1.1.9/lib/daemons/cmdline.rb:109:in `call'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/daemons-1.1.9/lib/daemons/cmdline.rb:109:in `catch_exceptions'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/daemons-1.1.9/lib/daemons.rb:196:in `run_proc'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/command.rb:90:in `run_process'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/command.rb:83:in `block in daemonize'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/command.rb:81:in `times'n/home/gius/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/delayed_job-4.0.1/lib/delayed/command.rb:81:in `daemonize'nbin/delayed_job:5:in `<main>'”], [“locked_at”, nil], [“locked_by”, nil], [“run_at”, “2014-05-31 21:13:45.225480”], [“updated_at”, “2014-05-31 21:13:39.230700”]] [1m[36m (8.3ms)[0m [1mCOMMIT[0m [1m[35mDelayed::Backend::ActiveRecord::Job Load (9.2ms)[0m UPDATE “delayed_jobs” SET locked_at = '2014-05-31 21:13:39.244149', locked_by = 'delayed_job.0 host:notebook pid:5367' WHERE id IN (SELECT “delayed_jobs”.“id” FROM “delayed_jobs” WHERE ((run_at <= '2014-05-31 21:13:39.243346' AND (locked_at IS NULL OR locked_at < '2014-05-31 17:13:39.243392') OR locked_by = 'delayed_job.0 host:notebook pid:5367') AND failed_at IS NULL) ORDER BY priority ASC, run_at ASC LIMIT 1 FOR UPDATE) RETURNING * [1m[36mTecnologiaEspionaje Load (0.2ms)[0m [1mSELECT “tecnologias”.* FROM “tecnologias” WHERE “tecnologias”.“type” IN ('TecnologiaEspionaje') AND “tecnologias”.“id” = $1 LIMIT 1[0m [[“id”, 1]] [1m[35m (0.2ms)[0m BEGIN [1m[36mCuenta Load (0.2ms)[0m [1mSELECT “cuentas”.*  FROM “edificios” WHERE “edificios”.“type” IN ('MinaCristal') AND “edificios”.“id” = $1 LIMIT 1 [[“id”, 3564]] [1m[36mPlaneta Load (0.3ms)[0m [1mSELECT “planetas”.* FROM “planetas” WHERE “planetas”.“id” = $1 LIMIT 1[0m [[“id”, 275]] [1m[35mMinaMetal Load (0.3ms)[0m SELECT “edificios”.* FROM “edificios” WHERE “edificios”.“type” IN ('MinaMetal') AND “edificios”.“planeta_id” = $1 LIMIT 1 [[“planeta_id”, 275]] [1m[36mPlaneta Load (0.2ms)[0m [1mSELECT “planetas”.* FROM “planetas” WHERE “planetas”.“id” = $1 LIMIT 1[0m [[“id”, 275]] [1m[35mPlantaEnergia Load (0.2ms)[0m SELECT “edificios”.* FROM “edificios” WHERE “edificios”.“type” IN ('PlantaEnergia') AND “edificios”.“planeta_id” = $1 LIMIT 1 [[“planeta_id”, 275]] [1m[36mMinaCristal Load (0.2ms)[0m [1mSELECT “edificios”.* FROM “edificios” WHERE “edificios”.“type” IN ('MinaCristal') AND “edificios”.“planeta_id” = $1 LIMIT 1[0m [[“planeta_id”, 275]] [1m[35mPlaneta Load (0.2ms)[0m SELECT “planetas”.* FROM “planetas” WHERE “planetas”.“id” = $1 LIMIT 1 [[“id”, 275]] [1m[36mPlantaEnergia Load (0.2ms)[0m [1mSELECT “edificios”.* FROM “edificios” WHERE “edificios”.“type” IN ('PlantaEnergia') AND “edificios”.“planeta_id” = $1 LIMIT 1[0m [[“planeta_id”, 275]] [1m[35m (0.2ms)[0m SELECT COUNT(*) FROM “edificios” WHERE “edificios”.“type” IN ('Mina', 'MinaCristal', 'MinaMetal') AND “edificios”.“planeta_id” = $1 AND (nivel >= 1) [[“planeta_id”, 275]] [1m[36mMinaMetal Load (0.2ms)[0m [1mSELECT “edificios”.* FROM “edificios” WHERE “edificios”.“type” IN ('MinaMetal') AND “edificios”.“planeta_id” = $1 LIMIT 1[0m [[“planeta_id”, 275]] [1m[35mMinaCristal Load (0.2ms)[0m SELECT “edificios”.* FROM “edificios” WHERE “edificios”.“type” IN ('MinaCristal') AND “edificios”.“planeta_id” = $1 LIMIT 1 [[“planeta_id”, 275]] [1m[36mMinaDeuterio Load (0.2ms)[0m [1mSELECT “edificios”.* FROM “edificios” WHERE “edificios”.“type” IN ('MinaDeuterio') AND “edificios”.“planeta_id” = $1 LIMIT 1[0m [[“planeta_id”, 275]] [1m[35mMinaDeuterio Load (0.2ms)[0m SELECT “edificios”.* FROM “edificios” WHERE “edificios”.“type” IN ('MinaDeuterio') AND “edificios”.“planeta_id” = $1 LIMIT 1 [[“planeta_id”, 275]] [1m[36mPlaneta Load (0.2ms)[0m [1mSELECT “planetas”.* FROM “planetas” WHERE “planetas”.“id” = $1 LIMIT 1[0m [[“id”, 275]] [1m[35m (0.1ms)[0m BEGIN [1m[36mSistema Load (0.2ms)[0m [1mSELECT “sistemas”.*


This is an optimization problem. It is based on OLD Homework 0510-9 at
http://www.math.umn.edu/~adams/MATH1271/hmwrkMATH1271.html.
L
be the line ax+by=c
.
Find the point on L
that is closest to
(x0,y0)
.p
/ lincoeff ,
q
/ lincoeff ) ",p
and q
are integers.
( -constcoeff / lincoeff ,
t*lincoeff+s*b*constcoeff / lincoeff )
Solving ax+by=c
for y
,
we get y=t-s*bx
.
Let f(x)
be the square of the distance from
(x,y)
to (x0,y0)
,
with y=t-s*bx
.
Then f(x)
is the square of the distance from
(x,t-s*bx
) to (x0,y0)
.
Then f(x)=[x-x0]^2+[t-b*sx-y0]^2
.
Then f'(x)=2[x-x0]+
2[t-b*sx-y0][-b*s]
.
Expanding, collecting terms, and factoring out 2
,
f'(x)=2(lincoeffx+constcoeff)
.
Expanding, collecting terms, and factoring out 2
,
f'(x)=2(lincoeffx--constcoeff)
.
Then f'(x)=0
if and only if x = -constcoeff/lincoeff
.
Also, f'(x)
is negative on x < -constcoeff/lincoeff
and positive on x > -constcoeff/lincoeff
.
Then f(x)
is decreasing on x < -constcoeff/lincoeff
and increasing on x > -constcoeff/lincoeff
.
Then f(x)
attains its minimum at x = -constcoeff/lincoeff
.
Since y=t-s*bx
it follows that,
when x = -constcoeff/lincoeff
,
we get y=t*lincoeff+s*b*constcoeff/lincoeff
.
In the "Answer" box, fill in -constcoeff
and t*lincoeff+s*b*constcoeff
,
so that it reads:
(-constcoeff/lincoeff,
t*lincoeff+s*b*constcoeff/lincoeff)


Friedersdorf is a right-of-center libertarian and a blogger for The Atlantic, and one of a handful of conservative bloggers whom I read regularly. In this post, he articulates his own position on birth control: ‘an enthusiastic embrace of easy access to birth control pills and intrauterine devices, coupled with a rejection of … free access to birth control for any woman’. In other words, Friedersdorf (a) is not a social conservative, opposed to birth control as such, but (b) is a right libertarian, opposed to public subsidies for birth control.
In the second titled section of this post,‘The Case Against Subsidized Birth Control For All’, Friedersdorf gives what I think is best read as two separable arguments against public subsidies for birth control. Here are some quotations – strung together from a few consecutive paragraphs – that give the first argument:
We’re now in the last stages of a transition to a health care system where what’s covered by health insurance …. is a matter of what our polity, through its elected representatives, bureaucrats accountable to them, and judges who aren’t, decide that we ought to provide to all citizens.
There are going to be redistributive consequences, or the equivalent of subsidies, no matter what health care system we choose. Resources are just going to flow from healthy people to diseased people. And it is widely thought that resources are spent unequally, but justly, when one man lives a healthy life and dies at age 60 in his sleep while another, who pays the same insurance premiums or taxes, contracts multiple sclerosis at age 45, requires two decades of costly care, and dies at 65.
Including birth control (as distinct from contraceptives used for other purposes) in universally mandated health-care coverage has its own unique redistributive effect, one that seems more problematic in a pluralistic society than funneling resources from the healthy to the sick or malfunctioning. Mandating participation in an insurance risk pool that covers birth control redistributes resources based partly on lifestyle choices, values, and conceptions of what is fulfilling. For example, gays and lesbians have no use for birth control, but are being made to participate in risk pools that cover it, effectively leaving them with fewer resources as a result of their status as a cultural minority group, rather than a part of the majority that desires birth control.
The crucial claim in this argument is that subsidizing birth control is unfair to GLBTQ citizens or (in a version that shows up later) is unfair to citizens who are morally opposed to birth control. What’s interesting is that this is an egalitarian liberal complaint, not a libertarian one – and recall that Friedersdorf is a right libertarian. A libertarian complains that redistribution (typically, redistribution as such) is involuntary; an egalitarian liberal complains that redistribution (typically, the distribution involved in a particular public policy proposal) is unfair.
Now, how does Friedersdorf understand fairness? If we focus on the ‘effectively leaving them with fewer resources’ bit, it might seem fairness is identified with Pareto optimality: a change to the status quo is unfair if and insofar as there is some individual with fewer resources after the change compared to the status quo. If this is right, then the egalitarian liberal talk of fairness is actually just a cover for right libertarianism: by this conception of fairness, taking more money from Mitt Romney to pay for homeless shelters is unfair. (The right libertarian philosopher Jan Narveson explicitly appeals to Pareto optimality in the crucial chapters of his book The Libertarian Idea.) In general, any policy that involves redistribution is unfair.
But this might not be the best way to read Friedersdorf. Let’s continue the quotation from the last paragraph: ‘effectively leaving them with fewer resources as a result of their status as a cultural minority group, rather than a part of the majority that desires birth control’. This suggests at least two ways of modifying the conception of fairness from the last paragraph:
- A change to the status quo is unfair if and insofar as there is some minority group opposed to the change with fewer resources after the change compared to the status quo.
- A change to the status quo is unfair if and insofar as there is some historically oppressed group with fewer resources after the change compared to the status quo.
Note that (1) leads us, more or less, back to right libertarianism again: Mitt Romney and most of the other members of the 1% are a minority group opposed to increasing the highest marginal tax bracket to 50% to pay for homeless shelters, and they would end up with fewer resources after the change compared to the status quo. So, according to (1), this change would be unfair. Now, if a majority voted to raise taxes on themselves and only themselves, this would qualify as fair. But I think most right libertarians would be fine with this, only quibbling about using the state rather than setting up a voluntary charitable organization.
(2), I think, is an honest-to-goodness egalitarian liberal principle. Mitt Romney is not a member of a historically oppressed group (at least with respect to his wealth; his religious beliefs are another matter), and so according to (2) it is not unfair to raise his taxes to pay for homeless shelters. But GLBTQ folks are a historically oppressed group, and the proposed subsidy would compel them to sacrifice for the benefit of historically privileged straights.
It’s a decent point. But I have two responses to it. First, I suggest that the strength of the argument depends on the relative size of the sacrifice: how much GLBTQ folks would be compelled to sacrifice and how much straights would stand to gain. I’m too lazy to look up estimates at the moment, but I expect the sacrifice would be rather small – on the order of a few dollars a month. Second, the primary beneficiaries would be not all straight folks, but women, also a historically oppressed group. So this argument, which seems to be about oppression vs. privilege, is more accurately about one kind of oppression vs. another.


Helps delegates and organisers of Model UNs manage the boring details of the conference debate from their phone, tablet, or computer. Everyone spends less time on the Rules of Procedure and more time on the debate
Create Speakers Lists. Have delegates add themselves to speak on them from their phone, tablet or computer. Shuffle the order and make sure you never lose track
Create a Poll and ask delegates to cast their Vote. See the Votes come in in real time and see whether or not the Vote has passed or failed
Message other delegates in real-time without needing to exchange your phone, email, or IM details
Create your own yieldto.me Profile- choose who you want to share your contact details with.  Keep in touch with everyone after the conference too


Google Maps will speak the names of foreign places so you can ask for directions without shame
The app will say the name of a place in a country’s local language
by Jay PetersGoogle Maps is incredibly useful when you’re navigating a country you’ve never been to before. (I couldn’t have survived a recent trip to Japan without it.) But sometimes, you still need to ask a real person to point you in the right direction, and you might not know how to say the name of the place you’re trying to get to. Soon, though, Google Maps may be able to help with that by speaking the name or address of a location in a country’s native language.
Here’s a GIF showing how the new feature works. I particularly like how you can look up additional phrases in Google Translate without leaving Google Maps, in case you want to continue a conversation or just say thanks:
Google tells The Verge that the feature will begin to roll out this month on both Android and iOS, with support for Cantonese, French, Japanese, Korean, Mandarin, Spanish, Russian, and more. The company’s blog post on the announcement says it will support 50 languages at launch, with support for even more “on the way.”


Waymo explains how first responders should handle self-driving cars [Video]
by Abner LiAhead of more and more self-driving cars appearing on the road, Waymo today published an instructional video on how first responders should interact with its autonomous vehicles in case of roadside emergencies.
This instructional video is designed to equip first responders to confidently identify, approach, and interact with Waymo fully self-driving vehicles in a wide range of collision and other emergency scenarios. Not all of the techniques described will be required during every interaction with a Waymo vehicle.
This “Guide for First Responders” offers “recommended techniques for emergency situations.” It starts off by learning how to identify the 2017 Chrysler Pacifica Hybrid due to the various sensors located on the roof, front, and sides of the vehicle.
To make sure the car does not self-drive, emergency responders are instructed to “make sure that at least one of the doors remains open until power has been disconnected or the vehicle has been shifted into manual mode.” The car will also not drive if an airbag is deployed.
The latter mode is achieved through a button combination on the steering wheel. Waymo also provided instructions to disable electric power. One special consideration is an extra 12-volt battery in the trunk that provides redundant power for the self-driving system.
More details and guides from Waymo are available online.
More about Waymo:
- Waymo self-driving tech used by Uber might result in licensing deal
- Waymo has been testing Wi-Fi in self-driving cars as latest rider perk
- Waymo gains approval for transporting passengers in self-driving cars in California
FTC: We use income earning auto affiliate links. More.


Welcome to Moneypoly!!
The most popular online monopoly game in the world!
GO!
Please Enter Your Name Here:
Choose How You Want to Play:
Or
Enter the room code here:


Color Source:
Presets:
Number of Lines:
Easing:
Easing Jitter:
Speed:
Speed Jitter:
Verticies:
Verticies Jitter:


Introduction
The Rust programming language helps you write faster, more reliable software. High-level ergonomics and low-level control are often at odds in programming language design; Rust challenges that conflict. Through balancing powerful technical capacity and a great developer experience, Rust gives you the option to control low-level details (such as memory usage) without all the hassle traditionally associated with such control.
If you're using Linux or macOS, open a terminal and enter the following command:
curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
The command downloads a script and starts the installation of the rustup tool, which installs the latest stable version of Rust. You might be prompted for your password. If the install is successful, the following line will appear:
Hello World
Now that you’ve installed Rust, let’s write your first Rust program. It’s traditional when learning a new language to write a little program that prints the text Hello, world! to the screen, so we’ll do the same here!
You’ll start by making a directory to store your Rust code. It doesn’t matter to Rust where your code lives, but for the exercises and projects in this book, we suggest making a projects directory in your home directory and keeping all your projects there. Open a terminal and enter the following commands to make a projects directory and a directory for the “Hello, world!” project within the projects directory. For Linux, macOS, and PowerShell on Windows, enter this:
$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world
Next, make a new source file and call it main.rs. Rust files always end with the .rs extension. If you’re using more than one word in your filename, use an underscore to separate them. For example, use hello_world.rs rather than helloworld.rs. Now open the main.rs file you just created and enter the code in Listing 1-1. Filename: main.rs
fn main() {
println!("Hello, world!");
}
Save the file and go back to your terminal window. On Linux or macOS, enter the following commands to compile and
run
the file:
$ rustc main.rs
$ ./main
Hello, world!
Regardless of your operating system, the string Hello, world! should print to the terminal.
Hello Cargo
Cargo is Rust’s build system and package manager. Most Rustaceans use this tool to manage their Rust projects because Cargo handles a lot of tasks for you, such as building your code, downloading the libraries your code depends on, and building those libraries. (We call libraries your code needs dependencies.)
Let’s create a new project using Cargo and look at how it differs from our original “Hello, world!” project. Navigate back to your projects directory (or wherever you decided to store your code). Then, on any operating system, run the following:$ cargo new hello_cargo
$ cd hello_cargo
The first command creates a new directory called hello_cargo. We’ve named our project hello_cargo, and Cargo creates its files in a directory of the same name. Go into the hello_cargo directory and list the files. You’ll see that Cargo has generated two files and one directory for us: a Cargo.toml file and a src directory with a main.rs file inside. It has also initialized a new Git repository along with a .gitignore file. Git files won’t be generated if you run cargo new within an existing Git repository; you can override this behavior by using cargo new --vcs=git.
Open Cargo.toml in your text editor of choice.
[package]
name = "hello_cargo"
version = "0.1.0"
authors = ["Your Name "]
edition = "2018"
[dependencies]
This file is in the TOML (Tom’s Obvious, Minimal Language) format, which is Cargo’s configuration format. The first line, [package], is a section heading that indicates that the following statements are configuring a package. As we add more information to this file, we’ll add other sections. The next four lines set the configuration information Cargo needs to compile your program: the name, the version, who wrote it, and the edition of Rust to use. Cargo gets your name and email information from your environment, so if that information is not correct, fix the information now and then save the file. We’ll talk about the edition key in Appendix E. The last line, [dependencies], is the start of a section for you to list any of your project’s dependencies. In Rust, packages of code are referred to as crates. We won’t need any other crates for this project, but we will in the first project in Chapter 2, so we’ll use this dependencies section then.
Now let’s look at what’s different when we build and run the “Hello, world!” program with Cargo! From your hello_cargo directory, build your project by entering the following command:
$ cargo build
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs
his command creates an executable file in target/debug/hello_cargo (or target\debug\hello_cargo.exe on Windows) rather than in your current directory.
$ cargo build Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo) Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/hello_cargo`
Hello, world!
When your project is finally ready for release, you can use cargo build --release to compile it with optimizations. This command will create an executable in target/release instead of target/debug. The optimizations make your Rust code run faster, but turning them on lengthens the time it takes for your program to compile. This is why there are two different profiles: one for development, when you want to rebuild quickly and often, and another for building the final program you’ll give to a user that won’t be rebuilt repeatedly and that will run as fast as possible. If you’re benchmarking your code’s running time, be sure to run cargo build --release and benchmark with the executable in target/release.
Common Programming Concepts
This chapter covers concepts that appear in almost every programming language and how they work in Rust. Many programming languages have much in common at their core. None of the concepts presented in this chapter are unique to Rust, but we’ll discuss them in the context of Rust and explain the conventions around using these concepts. Specifically, you’ll learn about variables, basic types, functions, comments, and control flow. These foundations will be in every Rust program, and learning them early will give you a strong core to start from.
By default variables are immutable. This is one of many nudges Rust gives you to write your code in a way that takes advantage of the safety and easy concurrency that Rust offers. However, you still have the option to make your variables mutable. Let’s explore how and why Rust encourages you to favor immutability and why sometimes you might want to opt out.
fn main() {
let x = 5;
println!("The value of x is: {}", x);
x = 6;
println!("The value of x is: {}", x);
}
You should receive an error message, as shown in this output:
$ cargo run
Compiling variables v0.1.0 (file:///projects/variables)
error[E0384]: cannot assign twice to immutable variable `x`
--> src/main.rs:4:5
|
2 | let x = 5;
| -
| |
| first assignment to `x`
| help: make this binding mutable: `mut x`
3 | println!("The value of x is: {}", x);
4 | x = 6;
| ^^^^^ cannot assign twice to immutable variable
error: aborting due to previous error
For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables`
To learn more, run the command again with --verbose.
This example shows how the compiler helps you find errors in your programs. Even though compiler errors can be frustrating, they only mean your program isn’t safely doing what you want it to do yet; they do not mean that you’re not a good programmer! Experienced Rustaceans still get compiler errors. The error message indicates that the cause of the error is that you cannot assign twice to immutable variable x, because you tried to assign a second value to the immutable x variable.
n Rust, the compiler guarantees that when you state that a value won’t change, it really won’t change. That means that when you’re reading and writing code, you don’t have to keep track of how and where a value might change. Your code is thus easier to reason through. But mutability can be very useful. Variables are immutable only by default; as you did in Chapter 2, you can make them mutable by adding mut in front of the variable name. In addition to allowing this value to change, mut conveys intent to future readers of the code by indicating that other parts of the code will be changing this variable’s value.
fn main() {
let mut x = 5;
println!("The value of x is: {}", x);
x = 6;
println!("The value of x is: {}", x);
}
We’re allowed to change the value that x binds to from 5 to 6 when mut is used. In some cases, you’ll want to make a variable mutable because it makes the code more convenient to write than if it had only immutable variables.
Being unable to change the value of a variable might have reminded you of another programming concept that most other languages have: constants. Like immutable variables, constants are values that are bound to a name and are not allowed to change, but there are a few differences between constants and variables. First, you aren’t allowed to use mut with constants. Constants aren’t just immutable by default—they’re always immutable. You declare constants using the const keyword instead of the let keyword, and the type of the value must be annotated. We’re about to cover types and type annotations in the next section, “Data Types,” so don’t worry about the details right now. Just know that you must always annotate the type. Constants can be declared in any scope, including the global scope, which makes them useful for values that many parts of code need to know about. The last difference is that constants may be set only to a constant expression, not the result of a function call or any other value that could only be computed at runtime. Here’s an example of a constant declaration where the constant’s name is MAX_POINTS and its value is set to 100,000. (Rust’s naming convention for constants is to use all uppercase with underscores between words, and underscores can be inserted in numeric literals to improve readability):
const MAX_POINTS: u32 = 100_000;
Constants are valid for the entire time a program runs, within the scope they were declared in, making them a useful choice for values in your application domain that multiple parts of the program might need to know about, such as the maximum number of points any player of a game is allowed to earn or the speed of light.
As you saw in the guessing game tutorial in the “Comparing the Guess to the Secret Number” section in Chapter 2, you can declare a new variable with the same name as a previous variable, and the new variable shadows the previous variable. Rustaceans say that the first variable is shadowed by the second, which means that the second variable’s value is what appears when the variable is used. We can shadow a variable by using the same variable’s name and repeating the use of the let keyword as follows:
fn main() {
let x = 5;
let x = x + 1;
let x = x * 2;
println!("The value of x is: {}", x);
}
This program first binds x to a value of 5. Then it shadows x by repeating let x =, taking the original value and adding 1 so the value of x is then 6. The third let statement also shadows x, multiplying the previous value by 2 to give x a final value of 12.
Shadowing is different from marking a variable as mut, because we’ll get a compile-time error if we accidentally try to reassign to this variable without using the let keyword. By using let, we can perform a few transformations on a value but have the variable be immutable after those transformations have been completed. The other difference between mut and shadowing is that because we’re effectively creating a new variable when we use the let keyword again, we can change the type of the value but reuse the same name. For example, say our program asks a user to show how many spaces they want between some text by inputting space characters, but we really want to store that input as a number:
fn main() {
let spaces = " ";
let spaces = spaces.len();
}
Data types
Every value in Rust is of a certain data type, which tells Rust what kind of data is being specified so it knows how to work with that data. We’ll look at two data type subsets: scalar and compound. Keep in mind that Rust is a statically typed language, which means that it must know the types of all variables at compile time. The compiler can usually infer what type we want to use based on the value and how we use it.
A scalar type represents a single value. Rust has four primary scalar types:
- integers
- floating-point number
- Booleans
- characters
- characters
An integer is a number without a fractional component. This type declaration indicates that the value it’s associated with should be an unsigned integer (signed integer types start with i, instead of u) that takes up 32 bits of space. Table 3-1 shows the built-in integer types in Rust. Each variant in the Signed and Unsigned columns (for example, i16) can be used to declare the type of an integer value.
| Lenght | Signed | Unsigned |
|---|---|---|
| 8-bit | i8 | u8 |
| 16-bit | i16 | u16 |
| 32-bit | i32 | u32 |
| 64-bit | i64 | u64 |
| 128-bit | i128 | u128 |
| arch | isize | usize |
Each variant can be either signed or unsigned and has an explicit size. Signed and unsigned refer to whether it’s possible for the number to be negative—in other words, whether the number needs to have a sign with it (signed) or whether it will only ever be positive and can therefore be represented without a sign (unsigned). It’s like writing numbers on paper: when the sign matters, a number is shown with a plus sign or a minus sign; however, when it’s safe to assume the number is positive, it’s shown with no sign. Signed numbers are stored using two’s complement representation. Each signed variant can store numbers from -(2n - 1) to 2n - 1 - 1 inclusive, where n is the number of bits that variant uses. So an i8 can store numbers from -(27) to 27 - 1, which equals -128 to 127. Unsigned variants can store numbers from 0 to 2n - 1, so a u8 can store numbers from 0 to 28 - 1, which equals 0 to 255.
Rust also has two primitive types for floating-point numbers, which are numbers with decimal points. Rust’s floating-point types are f32 and f64, which are 32 bits and 64 bits in size, respectively. The default type is f64 because on modern CPUs it’s roughly the same speed as f32 but is capable of more precision. Here’s an example that shows floating-point numbers in action:
fn main() {
let x = 2.0; // f64
let y: f32 = 3.0; // f32
}
Floating-point numbers are represented according to the IEEE-754 standard. The f32 type is a single-precision float, and f64 has double precision.
As in most other programming languages, a Boolean type in Rust has two possible values: true and false. Booleans are one byte in size. The Boolean type in Rust is specified using bool. For example:
fn main() {
let t = true;
let f: bool = false; // with explicit type annotation
}
So far we’ve worked only with numbers, but Rust supports letters too. Rust’s char type is the language’s most primitive alphabetic type, and the following code shows one way to use it. (Note that char literals are specified with single quotes, as opposed to string literals, which use double quotes.)
fn main() {
let c = 'z';
let z = 'ℤ';
let heart_eyed_cat = '😻';
}
A tuple is a general way of grouping together a number of values with a variety of types into one compound type. Tuples have a fixed length: once declared, they cannot grow or shrink in size. We create a tuple by writing a comma-separated list of values inside parentheses. Each position in the tuple has a type, and the types of the different values in the tuple don’t have to be the same. We’ve added optional type annotations in this example:
fn main() {
let tup: (i32, f64, u8) = (500, 6.4, 1);
}
Another way to have a collection of multiple values is with an array. Unlike a tuple, every element of an array must have the same type. Arrays in Rust are different from arrays in some other languages because arrays in Rust have a fixed length, like tuples. In Rust, the values going into an array are written as a comma-separated list inside square brackets:
fn main() {
let a = [1, 2, 3, 4, 5];
}
Arrays are useful when you want your data allocated on the stack rather than the heap (we will discuss the stack and the heap more in Chapter 4) or when you want to ensure you always have a fixed number of elements. An array isn’t as flexible as the vector type, though. A vector is a similar collection type provided by the standard library that is allowed to grow or shrink in size. If you’re unsure whether to use an array or a vector, you should probably use a vector.


{% extends "templates/web.html" %} {% block title %}Conference Home{% endblock %} {% from "foundation/templates/includes/macros.html" import media %} {% block page_content %} ERPNext Conferences Meet the community at the ERPNext Conferences. ERPNext Conference 2017 Join us for the annual confereence in Mumbai from October 10-12, 2017. There will be a code sprints, developer sessions and talks. Learn More Past Conferences ERPNext Europe Conference 2017, Frankfurt ERPNext Conference 2016, Mumbai ERPNext Conference 2015, Mumbai ERPNext Conference 2014, Mumbai {% endblock %}
Meet the community at the ERPNext Conferences.
Join us for the annual confereence in Mumbai from October 10-12, 2017. There will be a code sprints, developer sessions and talks. Learn More


AS IT HAPPENED: Xolani Gwala remembered at memorial service in Johannesburg
Cape Town - Friends and family of veteran radio personality Xolani Gwala bid him farewell at the first of two memorial on Wednesday.
The veteran radio personality died on Friday.
He succumbed to cancer at the age of 44 after making his diagnosis public in 2017.
News of the veteran broadcaster's death made headlines across the country with many reflecting on his log and illustrious career.
A memorial service will take place on Wednesday from 10:00 to 12:00 at Our Lady of Lourdes Rivonia Catholic Church.
WATCH THE LIVE BROADCAST HERE:
Xolani Gwala Memorial - Curated tweets by Channel24


---
layout: archive
title: Lean Prover Zulip Chat Archive
permalink: 116395maths/31786dadab.html
---
The archive URL format has changed. Please find this page at:
https://leanprover-community.github.io/archive/stream/116395-maths/topic/d.20.7C.20a.20-.3E.20d.20.7C.20(a.20*.20b).3F.html


No Crying in The Club (2018)
A family tree sprouts inside the corners of a frame. All that is inside reminds me of a time... Familiar leftovers of a song I used to recite in my sleep...'
In this project, I deal with my own history and changing relationship with home in Skopje, Macedonia. It was at the time, a summer of exploring my father's video camera together with tapes of my childhood. Taking these tapes, I filmed over them with new narratives of my family. Together, we retell stories and overwrite history with the same people, in the same place, 20 years later. The narrative tells of a storyteller, returning to a place that he was part of, a place he used to understand. Through ambiguous and emotional performances, the viewer is invited to take part on a vulnerable journey between imagination and memory.


Pull Requests gladly accepted How to Set Up DKIM (DomainKeys Identified Mail) with Postfix on Ubuntu 12.04 =
In the ongoing effort to combat spam, DomainKeys Identified Mail (DKIM) has risen as a popular method for email authentication. DKIM associates a particular domain name with an email message. The need for key-based authentication arose because spam often has forged headers.
This article assumes that you have completed the steps outlined in How To Install and Setup Postfix on Ubuntu 12.04 | DigitalOcean.
Internet Site
.Follow the steps outlined in Setting the Hostname & Fully Qualified Domain Name (FQDN) on Ubuntu 12.04 or CentOS 6.4 | GitHub.
Then, open a terminal and update the local package index on your server with the latest changes made in the software repositories and upgrade the software packages already installed on your system:
sudo apt-get update && sudo apt-get -y upgrade && sudo apt-get -y dist-upgrade && sudo apt-get -y autoremove
The configuration outlined in this tutorial will rely on OpenDKIM, an open source implementation of the DKIM sender authentication system.
To install OpenDKIM, execute:
sudo apt-get -y install opendkim opendkim-tools
As always, if you need help with the steps outlined in this How-to, look to the DigitalOcean Community for assistance by posing your question(s), below.
Pull Requests gladly accepted


The Parallel Workload Analyzer Homepage
The workload analyzer was written by David Talby to analyze traces of empirical and synthetic workloads of supercomputers. The program and its source code are freely available under this license. The program works on traces in the Standard Workload Format (version 2.0), and can produce synthetic workloads in this format based on several distributions.
The current version of the program is 4.4, and its strongest points are:
- Three methods of testing for self-similarity for any variable are programmed: The variance-time plot, the pox plot, and the periodogram.
- One can easily filter workloads based on any combinations of conditions. It is then possible to remove filtered records from the logs, save them in a separate file, or receive statistics regarding the records that possess the checked property.
- Whenever a workload file is read, each record (job) is checked for all validity constraints required by the standard workload format. Invalid records are discarded.
- All modules of the program handle missing values.
- It is possible to graphically plot the distribution, aggregated distribution over time, auto-correlation and linear regression between any two variables.
- The ability not only to produce new synthetic workloads, but also to alter specific fields of existing ones by adding or multiplying them with a selected distribution.
- Batch analysis support for summary statistics, self-similarity tests, auto-correlation tests and per-month summary analysis.
- A simple and coherent graphical user interface.


James May Has Bought Yet Another New Car
It's a "perfectly agreeable mid-size" sedan.
by Anthony KarrSo, you were disappointed when earlier this month James May showed his new car and it was not an Italian supercar but a blue Tesla Model S P100D? Prepare to be even more frustrated then, as May has just unveiled his second new car in a 12-minute video on Drivetribe.
Once again, don’t let the Porsche cover fool you as this is not a sports car from Stuttgart. It’s not a sports car at all, and it’s definitely not coming from Germany. It’s not even powered by a traditional internal combustion engine – May’s new ride is a Toyota Mirai FCEV in a machine silver color.
James May's Other Cars:
In the clip, the former Top Gear host explains the reasons behind his decision to buy the fuel-cell vehicle and also explains the differences between a regular battery electric vehicle and a fuel-cell EV. We bet you know these differences pretty well so May only spends several seconds in detailing the powertrain characteristics of the two cars.
Next, he talks about the actual efficiency of a fuel-cell vehicle and compares the everyday suitability of the Mirai and the Model S. Obviously, the Californian sedan has a big advantage when it comes to recharging as there are just eight hydrogen filling stations in the entire United Kingdom.
Gallery: 2017 Toyota Mirai: Review
“I don’t know what the future of the car is going to be. I’m fairly convinced that they’ll be powered by electric motors in one way or another but I don’t know what we are actually going to do about the management and storage the electricity,” May concludes.
So, if you have to choose between the Model S and the Mirai, which one would it be? Maybe May’s upcoming comparison test between the two could help you decide.
Source: Drivetribe


class SDCard – secure digital memory card¶
SD cards are one of the most common small form factor removable storage media.
SD cards come in a variety of sizes and physical form factors. MMC cards are
similar removable storage devices while eMMC devices are electrically similar
storage devices designed to be embedded into other systems. All three form
share a common protocol for communication with their host system and high-level
support looks the same for them all. As such in MicroPython they are implemented
in a single class called machine.SDCard
.
Both SD and MMC interfaces support being accessed with a variety of bus widths.
When being accessed with a 1-bit wide interface they can be accessed using the
SPI protocol. Different MicroPython hardware platforms support different widths
and pin configurations but for most platforms there is a standard configuration
for any given hardware. In general constructing an SDCard
object with without
passing any parameters will initialise the interface to the default card slot
for the current hardware. The arguments listed below represent the common
arguments that might need to be set in order to use either a non-standard slot
or a non-standard pin assignment. The exact subset of arguments supported will
vary from platform to platform.
-
class
machine.
SDCard
(slot=1, width=1, cd=None, wp=None, sck=None, miso=None, mosi=None, cs=None)¶ This class provides access to SD or MMC storage cards using either a dedicated SD/MMC interface hardware or through an SPI channel. The class implements the block protocol defined by
uos.AbstractBlockDev
. This allows the mounting of an SD card to be as simple as:uos.mount(machine.SDCard(), "/sd")
The constructor takes the following parameters:
slot selects which of the available interfaces to use. Leaving this unset will select the default interface.
width selects the bus width for the SD/MMC interface.
cd can be used to specify a card-detect pin.
wp can be used to specify a write-protect pin.
sck can be used to specify an SPI clock pin.
miso can be used to specify an SPI miso pin.
mosi can be used to specify an SPI mosi pin.
cs can be used to specify an SPI chip select pin.
Implementation-specific details¶
Different implementations of the SDCard
class on different hardware support
varying subsets of the options above.
PyBoard¶
The standard PyBoard has just one slot. No arguments are necessary or supported.
ESP32¶
The ESP32 provides two channels of SD/MMC hardware and also supports access to SD Cards through either of the two SPI ports that are generally available to the user. As a result the slot argument can take a value between 0 and 3, inclusive. Slots 0 and 1 use the built-in SD/MMC hardware while slots 2 and 3 use the SPI ports. Slot 0 supports 1, 4 or 8-bit wide access while slot 1 supports 1 or 4-bit access; the SPI slots only support 1-bit access.
Note
Slot 0 is used to communicate with on-board flash memory on most ESP32 modules and so will be unavailable to the user.
Note
Most ESP32 modules that provide an SD card slot using the dedicated hardware only wire up 1 data pin, so the default value for width is 1.
The pins used by the dedicated SD/MMC hardware are fixed. The pins used by the SPI hardware can be reassigned.
Note
If any of the SPI signals are remapped then all of the SPI signals will pass through a GPIO multiplexer unit which can limit the performance of high frequency signals. Since the normal operating speed for SD cards is 40MHz this can cause problems on some cards.
The default (and preferred) pin assignment are as follows:
Slot
0
1
2
3
Signal
Pin
Pin
Pin
Pin
sck
6
14
18
14
cmd
11
15
cs
5
15
miso
19
12
mosi
23
13
D0
7
2
D1
8
4
D2
9
12
D3
10
13
D4
16
D5
17
D6
5
D7
18
cc3200¶
You can set the pins used for SPI access by passing a tuple as the pins argument.
Note: The current cc3200 SD card implementation names the this class
machine.SD
rather than machine.SDCard
.


One was required to write a robot program that enables a robot to explore the arena and produce a map. The arena had a small number of obstacles, placed at random locations. There was a single coloured sheet of paper which the robots had to be able to detect using the colour sensor which also signifed the end location. When finished generating the map, the robot had navigate back to the ending position.
I mostly focused on the A* search task, and also provided the foundation for the LCD Occupancy Grid Display.
I looked into the different LCD
classes, and played around with TextLCD
and GraphicsLCD
to understand their differences, and to see when and how they could ‘overlap’ together. Interesting results revealed how one class only allowed to clear entire screen, where as the other allowed the user to clear a specific section by inputting coordinates.
I made the initial grid of rectangles, using the entire screen, by getting the width
and height
via the getWidth()
and getHeight()
methods, and diving them by the constant number of grids horizontally and vertically.
Made the foundational for-loops and if-statements to initialise the grid, and display a sample occupancy grid values such as 0
for empty, 1
for obstacle and 2
for final target position. Then added offset to the coordinates so the values would appear in the middle of each rectangle, rather than starting at the top left corner.
Finally, I started experimenting with trying to update the display values in real-time as the robot moved along, and explained to Adam several potential ways to do so before passing on the task and my code entirely to him.
I fully implemented the entire A*
search for the pathfinding by making two classes:
The first, AStarNode
, contains the information on the nodes used in the search, such as it’s X
and Y
coordinates position, it’s parent node, whether it’s an obstacle or not, and methods to calculate the manhattan distance from the current to target position.
The second, AStarSearch
, which extends the AStarNode
class, has the actual A* algorithm inside a while-loop, and several functions for detecting obstacles, building the best path List, initialising the nodes, searching the occupancy grid matrix for the target position, etc.
The main idea of the search is to divide the nodes into an open and closed list, for which a PriorityQueue
and Hash
were used instead of standard ArrayLists
, as they reduced the time complexity required to re-arrange or check the list by at least a magnitude.
The code was based on available generic A* pseudocode, and the main challenge was conceptualising the conversion from integer values in a 2D array
to nodes, and then converting them back in a [i,j]
format to be inserted in a returned list.


Libnet is a C library providing a high-level interface to packet injection primitives across many platforms. Previous to libnet, programmers had to wrestle with confusing, obscure, and poorly documented interfaces to build and write network packets. Libnet alleviates these problems and provides a well documented, simple API to quickly build portable programs that write network packets (figure 1).
Libnet was written for two main reasons:
Libnet is a wonderful utility for writing security-related applications, tools and modules. Many recent exploits have been rapidly developed using libnet as have many security related tools. The Packetfactory has many such examples.
This manual describes libnet in detail, including library internals and design decisions, as well as including step by step coding examples.
The primary author of libnet is Mike D. Schiffman<EMAIL_ADDRESS>However, libnet just wouldn't be libnet without the teeming masses of
other
way talented people who have helped out.


Raed El Naboulsi
Address: Tripoli, Lebanon
Mobile : +96170514137
Email<EMAIL_ADDRESS>Date of birth: 12/08/1995
Education
2013 - 2018
:
BE in Communication & Electronics Engineering
University
:
  Beirut Arab University
Certificates
Complete Coding Course ( Backend and Frontend Development) and Project management at Torch Academy
DIGITAL MARKETING A-Z PROGRAM at Intoact Training Center
CCNA routing & Switching:
Training course in ICDL (international computer driving license) modules
Participation in a 24-hour course in Android Design & Network Programming
Participation in a 30-hour course in Object–oriented Programming (Java)
Internships
2019
:
-Full-time Full-stack Web Developer at Codi Tech (ongoing)
2017
:
-Trainee at FIBERWAVES company: (1 month)
2016
:
-Trainee at OGERO telecom company: (1 month)
Work Experience
2019
:
- Freelance Online Marketing at Cell & Sell Stores (1 month)
2018
:
- English teacher at Center Al Fayhaa
- Data Entry at Azem & Saade association
Skills
Digital analysis & problem solving
Programming (SQL, Python, Html, Css, Java, Javascript)
Microsoft office
Written & verbal communication skills
Teamwork skills in assigned projects
Languages
Arabic
English
Personal Interests
Sports
Psychology
Music
Reading


To setup pants in your repo:
curl -L -O https://pantsbuild.github.io/setup/pants chmod +x pants touch pants.iniThe only requirement is that you have a python 2.7 interpreter somewhere on your PATH.
The first time you run the new ./pants
script it will install
the latest pants version and then run it.
On subsequent runs it will find the already installed pants and run it.
To pin the pants version, add an entry like so to pants.ini:
[GLOBAL] pants_version: 1.0.0If you use pants plugins published to pypi you can configure them as follows, also in pants.ini:
[GLOBAL] pants_version: 1.0.0 plugins: [ 'pantsbuild.pants.contrib.go==%(pants_version)s', 'pantsbuild.pants.contrib.scrooge==%(pants_version)s', ]Pants will notice you changed your plugins and install them.
NB: The formatting of the plugins list is important; all lines below the `plugins:` line must be indented by at least one white space to form logical continuation lines. This is standard for python ini files, see RFC #822 section 3.1.1 for the full rules python uses to parse ini file entries.


Vasont Inspire Models Documentation
Introduction
The GlobalLink Inspire CCMS Models is an open-source connector library, maintained by GlobalLink Vasont in GitHub, that provides the specific class models used within the Vasont Inspire Api and SDK.
The Inspire Web API is organized around REST. Our API has predictable resource-oriented URLs, accepts form-encoded request bodies, in almost all cases returns JSON-encoded responses, returns UTF-8 in most cases, and uses standard HTTP response codes, authentication, and verbs.
Developers who are working within the Inspire Preview environment (Sandbox, Demo, 3rd Party Developers) will work with Preview versions of the API and related SDK versions.
Live Inspire customers will work with LTS versions of the API and related SDK versions.
Just Getting Started?
Check out the SDK Documentation
Not A Developer?
Use apps and connectors developed by our partners to get started integrating your instance of Inspire with your tools and applications.


View user {{client.firstName}} {{client.lastName}} {{client.email}} Currency: {{client.currency.name}}


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import uk.gov.hmrc.fhregistrationfrontend.config.AppConfig @import uk.gov.hmrc.fhregistrationfrontend.views.html.layout @import uk.gov.hmrc.fhregistrationfrontend.views.ViewHelpers @import uk.gov.hmrc.govukfrontend.views.html.components._ @this(layout: layout, viewHelpers: ViewHelpers) @(timeSaved: String)(implicit request: Request[_], messages: Messages, appConfig: AppConfig) @pageTitle = @{ Messages("fh.delete_confirmation_page.header") } @layout(pageTitle) { @viewHelpers.form(action = uk.gov.hmrc.fhregistrationfrontend.controllers.routes.Application.deleteUserData) {
@Messages("fh.delete_confirmation_page.saved_on") @timeSaved
@Messages("fh.delete_confirmation_page.partially_completed")
@viewHelpers.govukButton(Button(content = Text(Messages("fh.delete_confirmation_page.button")))) } }


Class BoundedCurve
A bounded curve.
Inherited Members
Namespace: Elements.Geometry
Assembly: Hypar.Elements.dll
Syntax
public abstract class BoundedCurve : Curve, ICurve, ITransformable<Curve>, IBoundedCurve
Fields
DefaultMinimumChordLength
The minimum chord length allowed for subdivision of the curve. A smaller MinimumChordLength results in smoother curves. For polylines and polygons this parameter will have no effect.
Declaration
public const double DefaultMinimumChordLength = 0.1
Field Value
| Type | Description |
|---|---|
| System.Double |
Properties
Domain
The domain of the curve.
Declaration
[JsonIgnore]
public virtual Domain1d Domain { get; }
Property Value
| Type | Description |
|---|---|
| Domain1d |
End
The end of the curve.
Declaration
public virtual Vector3 End { get; protected set; }
Property Value
| Type | Description |
|---|---|
| Vector3 |
IsClosedForRendering
Should the curve be considered closed for rendering? Curves marked true will use LINE_LOOP mode for rendering. Curves marked false will use LINE_STRIP for rendering.
Declaration
[JsonIgnore]
public virtual bool IsClosedForRendering { get; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
Start
The start of the curve.
Declaration
public virtual Vector3 Start { get; protected set; }
Property Value
| Type | Description |
|---|---|
| Vector3 |
Methods
ArcLength(Double, Double)
Calculate the length of the curve between two parameters.
Declaration
public abstract double ArcLength(double start, double end)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | start | |
| System.Double | end |
Returns
| Type | Description |
|---|---|
| System.Double |
Bounds()
Get the bounding box for this curve.
Declaration
public abstract BBox3 Bounds()
Returns
| Type | Description |
|---|---|
| BBox3 | A bounding box for this curve. |
Frames(Double, Double, Double)
Get a collection of Transforms which represent frames along this curve.
Declaration
public virtual Transform[] Frames(double startSetbackDistance = 0, double endSetbackDistance = 0, double additionalRotation = 0)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | startSetbackDistance | The offset from the start of the ICurve. |
| System.Double | endSetbackDistance | The offset from the end of the ICurve. |
| System.Double | additionalRotation | An additional rotation of the frame at each point. |
Returns
| Type | Description |
|---|---|
| Transform[] | A collection of Transforms. |
GetSubdivisionParameters(Double, Double)
Get parameters to be used to find points along the curve for visualization.
Declaration
public abstract double[] GetSubdivisionParameters(double startSetbackDistance = 0, double endSetbackDistance = 0)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | startSetbackDistance | An optional setback from the start of the curve. |
| System.Double | endSetbackDistance | An optional setback from the end of the curve. |
Returns
| Type | Description |
|---|---|
| System.Double[] | A collection of parameter values. |
Length()
Calculate the length of the curve.
Declaration
public abstract double Length()
Returns
| Type | Description |
|---|---|
| System.Double |
Mid()
The point at the middle of the curve's parameter space.
Declaration
public virtual Vector3 Mid()
Returns
| Type | Description |
|---|---|
| Vector3 |
PointAtNormalized(Double)
Get a point along the curve at parameter u.
Declaration
public Vector3 PointAtNormalized(double u)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | u | A parameter along the curve between 0.0 and 1.0. |
Returns
| Type | Description |
|---|---|
| Vector3 | A point along the curve at parameter u. |
ToPolyline(Int32)
Create a polyline through a set of points along the curve.
Declaration
public virtual Polyline ToPolyline(int divisions = 10)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | divisions | The number of divisions of the curve. |
Returns
| Type | Description |
|---|---|
| Polyline | A polyline. |
TransformAtNormalized(Double)
Get a transform whose XY plane is perpendicular to the curve, and whose positive Z axis points along the curve.
Declaration
public Transform TransformAtNormalized(double u)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | u | The parameter along the curve between 0.0 and 1.0. |
Returns
| Type | Description |
|---|---|
| Transform | A transform. |
Operators
Implicit(BoundedCurve to ModelCurve)
Convert a bounded curve to a model curve.
Declaration
public static implicit operator ModelCurve(BoundedCurve c)
Parameters
| Type | Name | Description |
|---|---|---|
| BoundedCurve | c | The bounded curve to convert. |
Returns
| Type | Description |
|---|---|
| ModelCurve |


Essential Question
What were the struggles and conflicts of the Middle Ages and the ways in which political order was
achieved, including the role of the Catholic Church?
Struggles and Conflicts
There are many struggles and conflicts in Medieval European history, take as an example of the Black
Death and the Crusades.
 It is most commonly known for
killing 1/3 of Europe, it was eradicated due to the herd immunity law, social distancing, and other
unknown factors. This was a huge struggle since it caused an early death to millions of people.
Conflicts
There were also conflicts, such as the 3 crusades. The crusades were mostly about
ruling the “holy land” which was also known as Jerusalem. Jerusalem was holy to Muslims, Jews, and
Christens for many reasons. For Christens, Jesus practiced miracles, was crucified, and rose from the
dead here. There is also the Church of Holy Sepulchre. For Muslims, Mohammed rose from heaven in
Jerusalem and the Dome of Rock is there. For Jews, the capital of the Jewish nation is here and was the
location of the first temple, which was established by King Solomon. In the end, 4 things about medieval
Europe change. The power of the pope increased, and subsequently did the church, breakdown of feudalism
and growth of cities, beginning of loans and subsequently interest/credit, and new middle-eastern
products were starting to sprinkle in the European market such as pepper, muslin, chess, algebra,
coffee, rice, and more.
Political Order
In medieval times, there was feudalism. Feudalism is a structure of power and roles that consisted of a
King/Queen, Lords and Vassals, Knights (and their structure), Commoners, and Serfs (Slaves that owe a
debt). Kings\Queens were at the top of the food chain and ruled the land. Lords and Vassals are right
under the king and one of their most important jobs is to serve the king and he did so by paying his
taxes and supplying him with his finest soldiers. Knights started as Pages where they became Squires at
age 14, and they started to live with lords at age 7. Knighthood is only given if he is deserving of it,
and is treated as the inner circle of the best warriors. Commoners were everyday people in the village
and Serfs were slaves that had a debt. When their debt was paid, they would be free.
Role of the Church
In the Middle Ages, churches held a lot of political power (History of the Church in the Middle Ages).
In addition to being a religious institution sometimes, in the case of the Pope, hold more power than a
king or queen. The church had laws and can take taxes, in addition to having its punishments (sometimes
executions!). Churches were very much to be feared in the Middle Ages. In addition to this, they also
play a role in the Black Death, Feudalism, and the Crusades.
Role of the Church in the Black Death
The church pleaded that the Black Death, or what they called the “Pestilence”, was God punishing people
for their sins. They told people to pray and even organized religious marches to stop the plague.
Role of the Church in Feudalism
In feudalism, most of the population was catholic and bishops played a huge role. They usually hold very
valuable land and also lead the people, religiously. The church also uses a type of feudalism inside as
a power structure, the Pope is the King, the Bishop/Cardinal is second, and much more.
Role of the Church in the Crusades
The Crusades were a series of religious battles so if the Church wasn’t involved somehow, there would be
a big problem. The church was in a battle with the Jews and Muslims over control of the “holy land” also
known as Jerusalem. While it’s holy for different reasons to each group, for the Church, it’s where
Jesus performed miracles and was crucified/brought back to life here. In the end, it impacted all who
participated and changed how Muslims look at christens and “other hostile forces.”
Bibliography
McGraw Hill Impact World HIstory and Geography Medieval and Early Times Grade 7 Student Edition.
McGraw Hill, 2020.
Lyons, Professor. “Feudalism.” Feudalism, vol. 1, no. 1, 2020.
Lyons, Professor. “The Black Death.” The Black Death, vol. 1, no. 1, 2020.
“History with Mr. E - A Social Studies Professional.” History with Mr. E - A Social Studies
Professional
Movie Trailers. “Jerusalem - IMAX Trailer (2013) Daniel Ferguson Movie [HD].” YouTube, uploaded by
Movie Trailers, 16 Aug. 2013, www.youtube.com/watch?v=tejeDb_5WWs..
"History of the Church in the Middle Ages." Study.com, 15 November 2019, study.com/academy/lesson/history-of-the-church-in-the-middle-ages.html
“BRIA 26 2 The Black Death A Catastrophe in Medieval Europe” crf-usa.org, https://www.crf-usa.org/bill-of-rights-in-action/bria-26-2-the-black-death-a-catastrophe-in-medieval-europe.html
Thank You!
❮
❯


Yes I feel that not only did our President Donald Trump got this election stolen but every other candidates in all offices wad stolen along with Senate in Georgia Our country our election. We The People. One Nation Under God. In God We Trust. Land Of The Free And The Home Of The Brave. Was stolen from us 80,000,000 who voted for our wonderful President Donald Trump.
At the Highest Levels – Part 2 of 3 – Neon RevoltPart two of three. Read the first part here. …If, according to our whistleblower, Joseph Rosati was the one responsible for orchestrating the attack on Seth Rich, and potentially “clean…
http://api.parler.com/l/4sIGy
Holy hell is descending on DC. This is going to shock the nation is an understatement. LONG TIME COMING. THEY KNOW THEY KNOW EVERYTHING!! 7 Letters at elder Bush funeral.
This is a lot of information that was already . I love the way you make it easy to read and grip the circumstances of the situation as if you are seeking unfold before your own eyes thank You for the read sir . 🔥💪🙏❤⚔⚖🇺🇸🔔
Neon very insightful which some I knew but some the puzzle was not complete in my brain. This last month I completed the decodes. Having faith in the plan and knowingly if this plan somehow failed God would end life as we know it.  Grasp that, protect and defend God and his land,for it is his world he built it and will take it if it so be
Still waiting for part 2
Wow!
Where’s parts 2 and 3
I went to part 2 and it gave me a 500 error
Wow!! WTF!
Terrifying!
I sure hope President Trump is not relying on a Hail Mary pass to Pence because he will drop the ball on purpose.
Patriots 🇺🇸 🇺🇸
How many Democrats do you think really won their alleged elections?
5%, 10%, 25%, or 50% at the most?
American voters haven’t really elected anyone.
Democrats have cheated and selected everyone.
I read this on twitter tonight.  This is going to shock the nation is an understatement. LONG TIME COMING. THEY KNOW THEY KNOW EVERYTHING!! 7 Letters at elder Bush funeral.
This is a lot of information that was already . I love the way you make it easy to read and grip the circumstances of the situation as if you are seeking unfold before your own eyes thank You for the read sir . 🔥💪🙏❤⚔⚖🇺🇸🔔
So much makes sense now. Thank you. Now when is this arrest happening?!
I read this at 3am. That’s why I believe Trump is within striking range. Fireworks and shitstorm for DC is coming....
If this is going to happen, it needs to happen soon or we’ll lose out country forever.
Neon very insightful which some I knew but some the puzzle was not complete in my brain. This last month I completed the decodes. Having faith in the plan and knowingly if this plan somehow failed God would end life as we know it.  Grasp that, protect and defend God and his land,for it is his world he built it and will take it if it so be
What do all of these have in common?
Hillary Clinton
Seth Rich
Jeffery Epstein
Hollywood
Eric Snowden
John Brennan (maybe)
Barack Obama
?
Another question:
DoesSidney Powell have military prosecutorial abilities?
One more question:
If confidential information becomes declassified would that be allowed as evidence?


The Features of Caper
Generates modern C++ code!
- The parser is a template class.
- The template parameter is a type of node values and semantic action definition class (see Tutorial).
- Semantic action code is separate, so one grammar is reusable for another purpose.
- Semantic action is type safe because symbol type is provided at input grammar file.
- The parser class is simple and do nothing but analysis only.
- There are only 4 public member functions (
reset
,post
,accept
,error
).
Push-type parser similar to Lemon
- Does nothing until a token is
post
to the parser instance. - So, there is no concept of scanner (nor scanner cooperation).
- Cancellable halfway. There is no side effect on destruction when it became unnecessary.
- The allocation of parser instance can be on heap or on stack.
- Suspending/Resuming is unrestrained (it doesn't move if you don't post).
Output file is only one .hpp file.
- No other file required.
- No links to any libraries required.
- No include of headers (caper doesn't provide any headers).
- The generated parser is license free.
- You can say ``it's a handwritten code''.
- That includes only 3 headers (
<cassert>, <cstdlib>, <vector>
).
No global variables. No static variables. Clean design.
- Thread safe in the instance unit of parser.
- To use one instance from multiple threads, do exclusive control by yourself.
- Multiple parser instances are usable for one thread.
- There is no problem that multiple parsers different in grammar are usable for one thread.
- Multiple grammars are stored in each separate (user-defined) namespace, so usable in one executable file at ease.
- The parser doesn't do dynamic memory allocation basically.
- However there is an exception if STL is used for stack (used on default; changeable by option).
Strong against exception. You can raise exceptions in SemanticAction.
- It is easy to handle errors if you let exceptions raised in catchy grammar.
- We will discuss details later.
- The parser doesn't raise any exception.
- No exception required.
- If STL is used for stack, that may raise exceptions.
- The parser doesn't use RTTF.
- No RTTI required.
Performance is so-so (I think so).
No responsibility. No guarantee.
Advantages of Capar
Input File Is Simple
- The target grammar file is almost grammar only because semantic action is externally described.
Type Safe
- You can give type for token.
- You must set type to non-terminal symbol (the left side symbol of a grammar rule).
- You can check every type by above rules, that is used for semantic action at the right side of a grammar rule.
Warning!
This version is still beta. We didn't verify its stability yet. The specification may be changed (especially by demands). Treat as a toy.
The implementation of Stack<T> is very anxious when STL is off (especially T is complicated type).
Remove %dont_use_stl;
if it didn't work well when you specified it.
We want fix by C++ experts.


device,
deterministic: bool = False
):
states = torch.Tensor(state).to(device).unsqueeze(0)
action = actor(states, deterministic=deterministic)
action = action[0].cpu().numpy()
if self.action_clip is not None:
device,
deterministic: bool = False
):
states = _state2device(state, device)
action = actor(states, deterministic=deterministic)
action = action[0].cpu().numpy()
if self.action_clip is not None:


These are things that one day it would be cool to submit PRs or chat with maintainers about:
- Add link to GitHub to the Thor website
- This fix stops the user from typing in the wrong thing and throwing an exception, and instead now returns “invalid input” but wouldn’t it be better if it just plain didn’t allow invalid inputs to be typed at all, like elsehwere in
TTY
? https://github.com/piotrmurach/tty-prompt/issues/106


National Marathon Champions for Serbia & Montenegro (SCG)
Men (3 runnings) 23 Apr 2005 Beograd SER 2:35:20 Goran Cegar 24 Apr 2004 Beograd SER 2:32:27 Sreten Ninkovic-2 18 Oct 2003 Beograd SER 2:19:43 Sreten Ninkovic Non-Champion Race Winners 2005 2:12:10 Derba Bedade (ETH) 2004 2:12:53 Christopher Isengwe (TAN) 2003 2:14:48 Benson Ogato (KEN) Women (3 runnings) 23 Apr 2005 Beograd SER 2:42:48 Marjana Lukic-2 24 Apr 2004 Beograd SER 2:48:52 Marjana Lukic 18 Oct 2003 Beograd SER 2:44:34 Vesna Stevanovic Non-Champion Race Winners 2005 2:38:20 Inga Abitova (RUS) 2004 2:35:55 Rose Nyangacha (KEN) 2003 2:40:24 Zhanna Malkova (RUS)
Most Titles
Men
(2003-date)
2
Sreten Ninkovic
2003-04
Women
(2003-date) 2
Marjana Lukic
2004-05
Note:
For 1918 thru 2002, Serbia & Montenegro was part of Yugoslavia
For 2003 thru 2005, Serbia & Montenegro was a separate state
Click here for the list of champions for
Yugoslavia.
Last Updated on 24 Nov 2007
Contributors: Andy Milroy (5), Juraj Gasparovic (1)


Library of common methods for manipulating instances (tiles and extstreams).
Methods
-
<static> deleteExternalProps(instance) → {Promise}
-
Removes the map of extended properties on the instance, in the remote community.
Parameters:
Name Type Description instance
Object Returns:
Promise
- Type
- Promise
-
<static> find(keyValues, expectOne, cursor) → {Promise}
-
Find instances in persistence using the provided key-value criteria map. For example:
{ 'name': 'samplelist', 'config.number' : 25 }
On success, the returned promise will be resolved with an array of the located objects (which may be empty if none is found matching the criteria). If failure, the promise will be rejected with an error.Parameters:
Name Type Description keyValues
Object expectOne
Boolean If true, the promise will be resolved with at most 1 found item, or null (if none are found).
cursor
Boolean If true, the promise will be resolved with a collection cursor object.
Returns:
Promise
- Type
- Promise
-
<static> findAll(cursor) → {Promise}
-
Searches persistence for instances. The collection that is searched is defined in subclasses of this class (@see abstractInstances:getCollection). The promise will resolve with an empty array, or populated array, depending on whether any instances exist.
Parameters:
Name Type Description cursor
Boolean If true, the promise will be resolved with a collection cursor object.
Returns:
Promise
- Type
- Promise
-
<static> findByCommunity(communityName) → {Promise}
-
Searches persistence for an instance that matches the given community name (the 'community' attribute). The collection that is searched is defined in subclasses of this class (@see abstractInstances:getCollection). If one is not found, the promise will resolve a null (undefined) value.
Parameters:
Name Type Description communityName
String Returns:
Promise
- Type
- Promise
-
<static> findByDefinitionName(definitionName, cursor) → {Promise}
-
Searches persistence for instances that matches the given definition name (the 'name' attribute). The collection that is searched is defined in subclasses of this class (@see abstractInstances:getCollection). The promise will resolve with an empty array, or populated array, depending on whether any instances matched the search criteria.
Parameters:
Name Type Description definitionName
String cursor
Boolean If true, the promise will be resolved with a collection cursor object.
Returns:
Promise
- Type
- Promise
-
<static> findByGuid(guid) → {Promise}
-
Searches persistence for an instance that matches the given guid (the 'guid' attribute). The collection that is searched is defined in subclasses of this class (@see abstractInstances:getCollection). If one is not found, the promise will resolve a null (undefined) value.
Parameters:
Name Type Description guid
String Returns:
Promise
- Type
- Promise
-
<static> findByID(instanceID) → {Promise}
-
Searches persistence for an instance that matches the given ID (the 'id' attribute). The collection that is searched is defined in subclasses of this class (@see abstractInstances:getCollection). If one is not found, the promise will resolve a null (undefined) value.
Parameters:
Name Type Description instanceID
String Id of the instance to be retrieved.
Returns:
Promise
- Type
- Promise
-
<static> findByScope(scope) → {Promise}
-
Searches persistence for an instance that matches the given scope (the 'scope' attribute). The collection that is searched is defined in subclasses of this class (@see abstractInstances:getCollection). If one is not found, the promise will resolve a null (undefined) value.
Parameters:
Name Type Description scope
String Returns:
Promise
- Type
- Promise
-
<static> findByURL(url) → {Promise}
-
Searches persistence for an instance that matches the given push URL (the 'url' attribute). The collection that is searched is defined in subclasses of this class (@see abstractInstances:getCollection). If one is not found, the promise will resolve a null (undefined) value.
Parameters:
Name Type Description url
String Returns:
Promise
- Type
- Promise
-
<static> getExternalProps(instance) → {Promise}
-
Retrieves a map of extended properties set on the instance, in the remote jive community.
Parameters:
Name Type Description instance
Object Returns:
Promise
- Type
- Promise
-
<static> refreshAccessToken(instance) → {Promise}
-
Performs an OAuth2 access token refresh with the jive community associated with the passed in instance. If successful, the promise is resolved with the instance object containing the new access token (accessToken). Note that the changes to the instance is not actually saved into persistence at this point.
Parameters:
Name Type Description instance
Object Must contain the following fields:
Properties
Name Type Description jiveCommunity
String Points to an existing community
refreshToken
String Refresh token used for acquiring a new access token
Returns:
Promise
- Type
- Promise
-
<static> register(jiveUrl, pushUrl, config, name, code, guid) → {Promise}
-
Registers a new tile or extstream instance:
- Try to locate a community based on the jiveUrl
- If no community is located matching the jiveUrl, the returned promise is rejected with an error.
- If a community is located, do an OAuth2 access token exchange with that server using the authorization code ('code') provided.
- A tile or extstream instance is created (or updated, if it already exists) using the oauth credentials and register parameters, and resolved on the returned promise.
Parameters:
Name Type Description jiveUrl
String pushUrl
String config
Object name
String code
String guid
String Returns:
Promise
- Type
- Promise
-
<static> remove(instanceID) → {Promise}
-
Removes an instance from persistence with the specified id (attribute 'id'). The collection that is searched is defined in subclasses of this class (@see abstractInstances:getCollection).
Parameters:
Name Type Description instanceID
String Returns:
Promise
- Type
- Promise
-
<static> save(instance) → {Promise}
-
Save an instance to persistence. If the object does not have an id attribute, a random String is assigned. If the object is already present in persistence, it will be updated; otherwise it will be inserted. On success, the returned promise will be resolved with the inserted or updated object; if failure, the promise will be rejected with an error.
Parameters:
Name Type Description instance
Object Returns:
Promise
- Type
- Promise
-
<static> setExternalProps(instance, props) → {Promise}
-
Sets a map of extended properties on the instance, in the remote jive community.
Parameters:
Name Type Description instance
Object props
Object Returns:
Promise
- Type
- Promise


See the Pen KdpGrM by Kaijie Huang (@hkjpotato) on CodePen.
Using CSS3 (3d rotation), I try to reproduce the animation effect of an android operating system named Smartisan OS.
AngularJS and SCSS are used to simplify the complexity of the code.
Dynamic data binding makes the outlook of every facade of the cubes changable.
Special concerns are given to some specific animation effect. (e.g hover effect of the color icons)
Details count! Parameters such as animation duration and frames are well tuned so as to provide a sense of harmony.
Through this project, I want to train myself to reproduce popular animation effects on other platforms such as IOS & Android. In the age of CSS3, I believe the touch heart moment created by entrancing animation is a key to enhance user experience and viscosity of a product.
The source materials are obtained from the official website of Smartisan's new Phone, JianGuo™. I use Photoshop to slice each facade of the cubes from the original images. Besides, I also reference the some of the codes of the original website.
您好，如有版权问题，请与我联系。


Parrafo Ejerecicio 009
a=33;
b=10;
Value of a => (a = b) => 10
C = A + B will assign the value of A + B into C
Value of a => (a += b) => 20
C += A is equivalent to C = C + A
Value of a => (a -= b) => 10
C -= A is equivalent to C = C - A
Value of a => (a *= b) => 100
C *= A i equivalent to C = C * A
Value of a => (a /= b) => 10
C /= A is equivalent to C = C / A
Value of a => (a %= b) => 0
C %= A is equivalent to C = C % A
| Inicio |


Brian Sinclair, EmpireJS 2016
#acca11y #empirejs
@brianarn
)Often abbreviated as a11y
All about varying ability/disability
Better accessibility helps everyone
Sorta
POUR codified into rule sets
Accessibility is like a blueberry muffin—you can't push the berries in there afterward.
Cordelia McGee-Tubb
<!doctype>

<button>
alt
attributes on imagesalt=""
is ok!
Oft ignored, but important!
*:focus{ outline: none; }
*:focus{ outline: none; }
Redefine what things are

<button class="close-button" aria-label="close">

</button>
Worth using, but semantic markup will usually be better


Alright! We're on the second page now. Let's dive deeper into HTML, starting with...
We actually have 6 different levels of headings to utilize, using

through

tags.
Notice how the

heading above is a bit smaller than
the first level.
There are several different tags for lists in HTML, listed below in an unordered list:

tag - for unordered lists

tag - for ordered lists

tag - for description lists (less frequently used)
The "ul" and "ol" tags use the

tag for list items.
The "dl" tag has its own

and

tags for definition terms. Above was an unordered list, below is an ordered list
and a descriptive list.
Note: you cannot place a list tag inside a p
tag
Here is an ordered list:
Here is a descriptive list:
Now let's include an image - we'll use the
tag.
The image tag above contains two attributes - src
and alt
.
The value of the "src" attribute specifies the URL of the image, and the
"alt" attribute allows you to display alternative text if the image cannot
be loaded for some reason.
The image tag is a self-closing tag, meaning that instead of
having a separate tag to end the element, the tag itself ends the element
with a />
and no other tags are nested within it.
We can also set the height and width of an image, using the height
and width
attributes. Below, we made the cat image 75 × 50 pixels.
Tables can be included in HTML using the - yes, you guessed it -

tag.
There are actually several different table tags, listed below. Optional tags
are marked with an *.

- defines a caption for the table. If used, must go directly after the

tag

- defines the header row for the table
- defines a table header cell

- defines the body of the table. Not needed if header not specified

- groups the footer content of the table

- defines a table row
- defines a table data cell in the bodyA sample table is shown below:
| Header A | Header B | Header C |
|---|---|---|
| Cell 1A | Cell 1B | Cell 1C |
| Cell 2A | Cell 2B | Cell 2C |
| Cell 3A | Cell 3B | Cell 3C |
| Footer A | Footer B | Footer C |
Forms are arguably one of the most important types of tags - you'll use forms to gather input from the user. A list of common form tags are listed below:
<form>
- for specifying an entire form<input>
- some kind of user input, depending on the type
attribute:
text
- for inline textnumber
color
- displays a color pickerdate
- displays a date pickerfile
range
- specify a range of numbers with min
and max
attributestel
- telephone numberpassword
- will hide the characters enteredradio
- a radio button (group of options where the user can only select one)checkbox
- user can select multiple options<button>
- a user-clickable button<select>
- a dropdown menu with options specified by the option
tag<textarea>
- a multi-lined, resizable text field
- defines a label for an input element
Form inputs can have the name
attribute to identify the fields.
The values of the name
attribute are used as the keys for
the user data when the form is submitted and sent to a server for processing.
HTML5 is the newest version of HTML, and many existing tags were deprecated while new tags were introduced. The point of new HTML5 tags is to make HTML markup more semantic - meaning that the tags should reflect the meaning of the content, defining more clearly what the content is, not simply how it is displayed. Here are some HTML5 semantic tags:

- defines heading of a page
- defines footer of a page

- defines an article
- content aside from the main content
- navigation section
- the main content of the page

- logically split content into sections
- additional details the user can view or hide
- visible heading for "details" element
- marked / highlighted textThe most useful of these will be the header, footer, and nav tags. Instead of using divs for each of these sections, the semantic tags can be used.
As you can see, there are MANY, MANY HTML tags out there. We won't go through all of them, but there is a comprehensive list on W3Schools. In fact, that whole website is great for HTML and CSS reference material, so go explore it. And when you're ready, let's go to the next page!


A project to learn Java and create software for Mindstorms Robots using hardware supported by EV3Dev & the LeJOS way.
1. Introduction
Lego Mindstorms ecosystem is
a fantastic educational way to learn Java, Linux and Robotics
to develop your creativity using your favourite Bricks.
In the the third generation of the product Lego Mindstorms EV3,
others companies like Dexter Industries
& Mindsensors has released boards combining the power of
Raspberry Pi 3 with the usage of Sensors & Actuators from Lego Mindstorms ecosystem.
The result is very healthy for the Community but… some questions appear in the air:
-
How to manage the hardware in an easy way?
-
How to continue using Java with all boards?
-
What happen with amazing LeJOS libraries about
local-navigation
in this context?
The answer is this project, EV3Dev-lang-java.
2. Project architecture
The project has been designed with the following solution in mind:
| Layer | Option 1 | Option 2 |
|---|---|---|
ev3dev-lang-java |
0.7.0 |
2.4.16 |
Platforms |
BrickPi BrickPi3 PiStorms |
EV3 |
OS |
Debian Jessie |
Debian Jessie/Stretch |
JVM |
OpenJDK 11 |
OpenJDK JRI 11/12 ea |
EV3Dev Kernel |
4.4.47-19-ev3dev-ev3 4.4.47-19-ev3dev-rpi2 |
4.14.71-ev3dev-2.3.0-ev3 |
Note: At the moment, the whole solution is scalable until the next LEGO Mindstorms
product estimated
for next January of 2020.
3. Features included
Java features
-
OpenJDK Java 11/12 ea support for EV3 Brick, Brickpi+/PiStorms + Raspberry Pi 3
-
Java profiling tools Support (Oracle mission control & JConsole)
-
Logging support based on SLF4J
-
Centralized logs with Kibana
Platform features
-
Support for EV3 Brick, PiStorms v1/v2, BrickPi+ & BrickPi 3
Lego Mindstorms features
-
Regulated Motor Support
-
Unregulated Motor Support
-
Sensor Support (EV3 sensors)
-
Sounds Support
-
EV3 LCD Support
Robotics
-
Automatic installation of OpenCV
-
eSpeak TTS (Text to speech) Support
-
LeJOS Sensor filter Support
-
LeJOS local navigation stack Support
-
RPLidar A1/A2 (2D Lidar) Support
4. Subprojects
Stable projects:
-
OpenJDK for EV3: A custom OpenJDK JRE build for EV3
-
EV3Dev-lang-java: Low level interation with EV3Dev
-
lejos-commons: LeJOS interfaces & utilities
-
Installer: A set of Bash scripts to automate some operations with your brick
-
Template project: A Gradle project ready to test the project
-
Examples: A repository with several examples about the usage of this project
Incubator projects:
-
lejos-navigation: LeJOS navigation stack
-
Usb Devices: A library to use Arduino, Grove Sensors, GPS, IMU, LIDAR, and more devices…
-
ROS: A library to publish Sensor data to ROS for SLAM purposes
5. Competitive advantages
The competitive advantages of this project are:
-
Development Java robots with modern Java versions
-
Support for Multiple Bricks like EV3 Brick, BrickPi & PiStorms
-
Support for
USB
Connections for Sensors like 2D LIDARs, IMU & GPS &Arduino
Boards -
Usage of
LeJOS
interfaces
If you analyze the hardware, any EV3 Brick uses a
SoC: Sitara Processor AM1808
(from year 2010) to manage Sensors &
Actuators but now with the usage of a BrickPi/PiStorms unit, it is
possible to use the power of a Raspberry Pi 3 increasing the
possibilities to develop complex projects which require por
Computational consumption.
| Element | LEGO | Raspberry Pi 3 Model B+ |
|---|---|---|
Year |
2010 |
2018 |
Hardware |
EV3 Brick |
BrickPi+ BrickPi3 PiStorms |
SoC |
Sitara Processor AM1808 |
Broadcom BCM2837 RISC de 64 bits |
CPU |
ARM9 300MHz / 456 Mhz |
4× ARM Cortex-A53, 1.4GHz |
RAM |
16KB of Instruction Cache, 16KB of Data Cache, 8KB of RAM (Vector Table), 64KB of ROM |
1GB LPDDR2 (900 MHz) |
USB |
1x |
4x |
6. Timeline of the project
In 2015, EV3Dev was born to offer a solution to install a complete Linux Debian Operating System on EV3 Brick, BrickPi Series & PiStorms Series. The project provides an agnostic Linux interface to unify the way to interact with Mindstorms Hardware too.
At the end of the same year, EV3Dev-lang-java
was born with the idea to continue developing Java robots
on Lego Mindstorms and providing a port of LeJOS
libraries like the local-navigation
stack.
In the future, we will add the remote
support and ROS
support.
7. Evolution of Java on Lego Mindstorms ecosystem
LeJOS project is the unique Open Source project available for every Lego Mindstorms generations of the product. In any generation, the project had to find a solution for the following layers:
-
Runtime
-
JVM
-
Robotics libraries
This premise was solved in every Mindstorms generation:
| Product | RCX | NXT | EV3 + LeJOS | EV3/BrickPi/PiStorms + EV3Dev-lang-java |
|---|---|---|---|---|
Last release |
17/12/2006 |
03/02/2015 |
16/11/2015 |
13/11/2018 |
Runtime |
Custom firmware |
Custom firmware |
Busybox + Native libraries |
Debian Jessie/Stretch |
JVM |
Custom JVM |
Custom JVM |
Oracle JRE 8 |
OpenJDK 11/12 ea |
Robotics libraries |
Initial libraries |
local-navigation, remote, ros |
local-navigation, remote |
local-navigation |


Works by: Edit menu, right-click
Hot keys: None
Source requirements: One or more source relationships required - see below for special requirements for the source relationships
Target requirement: No target required
The Destroy operation permanently removes a term from the ontology. When a term is destroyed, it is gone forever. It does not appear in the obsolete list.
To destroy a term, first make sure that it has at most one parent relationship (if it has more, first delete those other relationships). Then, select the term, and choose "Destroy" from the right-click or edit menu. A warning message will appear:
Choose "Yes" to destroy the term, or "No" to cancel.
The Destroy operation can also be used to destroy a root terms and obsolete terms. To destroy a root or obsolete term, select the term, and choose "Destroy" from the right-click or edit menu. Choose "Yes" when the warning message appears to destroy the term.


Instructions
1> Select the code you want to compile
2> Press any of the following key combination to compile the code in respective language
Key Bindings
alt-b
C
alt-c
CPP11
alt-o
CLOJURE
alt-s
CSHARP
alt-a
JAVA
alt-j
JAVASCRIPT
alt-h
HASKELL
alt-l
PERL
alt-k
PHP
alt-p
PYTHON
alt-r
RUBY


{% extends 'multiplicity/base.html' %} {% load static %} {% block title %}Task forces{% endblock %} {% block container %}stretch-bg-head{% endblock %} {% block content %}
This page provides an overview of the different task forces that we have at Metabolism of Cities. We always look for people to join our task forces! If you are keen to help us and become part of our group, please have a look at the list below and let us know which one(s) you would like to join. Our task force lead will then indicate what assignments are available and how you can assist.
{% for info in list %}{{ info.category_description|linebreaksbr }}
{% endfor %}


{{noScalpApp.thisNode}}
Distribute tickets
Registered distributions:
Hit "Distribute tickets" to register ticket distribution.
Tickets: {{distribution.tickets}}
Event name: {{distribution.event}}
Distributor: {{distribution.toDistributor}}


An R package to automatically fetch data from the UK Parliament API. Ironically, Hansard data is not yet accessible through the API. To explore all available data see http://www.data.parliament.uk/. Documentation for the API itself is available here.
Like the UK parliament API, this package is a work in progress. Additional functionalities will be added to the package as they are developed in the API. The most up-to-date documentation for this package will always be available at https://docs.evanodell.com/hansard/.
To install from CRAN run:
install.packages("hansard")
To install the development version run:
#install.packages("remotes")
remotes::install_github("evanodell/hansard")
For an introduction to hansard
, please see the vignette. If you are unfamiliar with web APIs this introductory course is useful.
This package is in no way officially related to or endorsed by the UK Parliamentary Data Service. It is released under an MIT license. Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.
This package is part of rOpenGov. Evan Odell is the creator and maintainer.