--- layout: post title: "Self-hosted integration tests in ASP.NET" description: "A way to self-host a REST API and test it through HTTP." date: 2021-01-25 7:45 UTC tags: [Unit Testing, ASP.NET Web API, ASP.NET MVC] --- {% include JB/setup %}
{{ page.description }}
In 2020 I developed a sizeable code base for an online restaurant REST API. In the spirit of outside-in TDD, I found it best to test the HTTP behaviour of the API by actually interacting with it via HTTP.
Sometimes ASP.NET offers more than one way to achieve the same end result. For example, to return 200 OK
, you can use both OkObjectResult
and ObjectResult
. I don't want my tests to be coupled to such implementation details, so by testing an API via HTTP instead of using the ASP.NET object model, I decouple the two.
You can easily self-host an ASP.NET web API and test it using an HttpClient. In this article, I'll show you how I went about it.
The code shown here is part of the sample code base that accompanies my book Code That Fits in Your Head.
In true outside-in fashion, I'll first show you the test. Then I'll break it down to show you how it works.
[Fact] public async Task ReserveTableAtNono() { using var api = new SelfHostedApi(); var client = api.CreateClient(); var at = DateTime.Today.AddDays(434).At(20, 15); var dto = Some.Reservation.WithDate(at).WithQuantity(6).ToDto(); var response = await client.PostReservation("Nono", dto); await AssertRemainingCapacity(client, at, "Nono", 4); await AssertRemainingCapacity(client, at, "Hipgnosta", 10); }
This test uses xUnit.net 2.4.1 to make a reservation at the restaurant named Nono. The first line that creates the api
variable spins up a self-hosted instance of the REST API. The next line creates an HttpClient
configured to communicate with the self-hosted instance.
The test proceeds to create a Data Transfer Object that it posts to the Nono restaurant. It then asserts that the remaining capacity at the Nono and Hipgnosta restaurants are as expected.
You'll see the implementation details soon, but I first want to discuss this high-level test. As is the case with most of my code, it's far from perfect. If you're not familiar with this code base, you may have plenty of questions:
The three other questions are all related. A bit of background is in order. I wrote this test during a process where I turned the system into a multi-tenant system. Before that change, there was only one restaurant, which was Hipgnosta. I wanted to verify that if you make a reservation at another restaurant (here, Nono) it changes the observable state of that restaurant, and not of Hipgnosta.
The way these two restaurants are configured, Hipgnosta has a single communal table that seats ten guests. This explains why the expected capacity of Hipgnosta is 10. Making a reservation at Nono shouldn't affect Hipgnosta.
Nono has a more complex table configuration. It has both standard and communal tables, but the largest table is a six-person communal table. There's only one table of that size. The next-largest tables are four-person tables. Thus, a reservation for six people reserves the largest table that day, after which only four-person and two-person tables are available. Therefore the remaining capacity ought to be 4.
The above test knows all this. You are welcome to criticise such hard-coded knowledge. There's a real risk that it might make it more difficult to maintain the test suite in the future.
Certainly, had this been a unit test, and not an integration test, I wouldn't have accepted so much implicit knowledge - particularly because I mostly apply functional architecture, and pure functions should have isolation. Functions shouldn't depend on implicit global state; they should return a value based on input arguments. That's a bit of digression, though.
These are integration tests, which I mostly use for smoke tests and to verify HTTP-specific behaviour. I have unit tests for fine-grained testing of edge cases and variations of input. While I wouldn't accept so much implicit knowledge from a unit test, I find that it so far works well with integration tests.
It only takes a WebApplicationFactory to self-host an ASP.NET API. You can use it directly, but if you want to modify the hosted service in some way, you can also inherit from it.
I want my self-hosted integration tests to run as state-based tests that use an in-memory database instead of SQL Server. I've defined SelfHostedApi
for that purpose:
internal sealed class SelfHostedApi : WebApplicationFactory<Startup> { protected override void ConfigureWebHost(IWebHostBuilder builder) { builder.ConfigureServices(services => { services.RemoveAll<IReservationsRepository>(); services.AddSingleton<IReservationsRepository>(new FakeDatabase()); }); } }
The way that WebApplicationFactory
works, its ConfigureWebHost
method runs after the Startup
class' ConfigureServices
method. Thus, when ConfigureWebHost
runs, the services
collection is already configured to use SQL Server. As Julius H so kindly pointed out to me, the RemoveAll
extension method removes all existing registrations of a service. I use it to remove the SQL Server dependency from the system, after which I replace it with a test-specific in-memory implementation.
Since the in-memory database is configured with Singleton lifetime, that instance is going to be around for the lifetime of the service. While it's only keeping track of things in memory, it'll keep state until the service shuts down, which happens when the above api
variable goes out of scope.
Notice that I named the class by the role it plays rather than which base class it derives from.
The PostReservation
method is an extension method on HttpClient
:
internal static async Task<HttpResponseMessage> PostReservation( this HttpClient client, string name, object reservation) { string json = JsonSerializer.Serialize(reservation); using var content = new StringContent(json); content.Headers.ContentType.MediaType = "application/json"; var resp = await client.GetRestaurant(name); resp.EnsureSuccessStatusCode(); var rest = await resp.ParseJsonContent<RestaurantDto>(); var address = rest.Links.FindAddress("urn:reservations"); return await client.PostAsync(address, content); }
It's part of a larger set of methods that enables an HttpClient
to interact with the REST API. Three of those methods are visible here: GetRestaurant
, ParseJsonContent
, and FindAddress
. These, and many other, methods form a client API for interacting with the REST API. While this is currently test code, it's ripe for being extracted to a reusable client SDK library.
I'm not going to show all of them, but here's GetRestaurant
to give you a sense of what's going on:
internal static async Task<HttpResponseMessage> GetRestaurant(this HttpClient client, string name) { var homeResponse = await client.GetAsync(new Uri("", UriKind.Relative)); homeResponse.EnsureSuccessStatusCode(); var homeRepresentation = await homeResponse.ParseJsonContent<HomeDto>(); var restaurant = homeRepresentation.Restaurants.First(r => r.Name == name); var address = restaurant.Links.FindAddress("urn:restaurant"); return await client.GetAsync(address); }
The REST API has only a single documented address, which is the 'home' resource at the relative URL ""
; i.e. the root of the API. In this incarnation of the API, the home resource responds with a JSON array of restaurants. The GetRestaurant
method finds the restaurant with the desired name and finds its address. It then issues another GET
request against that address, and returns the response.
The verification phase of the above test calls a private helper method:
private static async Task AssertRemainingCapacity( HttpClient client, DateTime date, string name, int expected) { var response = await client.GetDay(name, date.Year, date.Month, date.Day); var day = await response.ParseJsonContent<CalendarDto>(); Assert.All( day.Days.Single().Entries, e => Assert.Equal(expected, e.MaximumPartySize)); }
It uses another of the above-mentioned client API extension methods, GetDay
, to inspect the REST API's calendar entry for the restaurant and day in question. Each calendar contains a series of time entries that lists the largest party size the restaurant can accept at that time slot. The two restaurants in question only have single seatings, so once you've booked a six-person table, you have it for the entire evening.
Notice that verification is done by interacting with the system itself. No Back Door Manipulation is required. I favour this if at all possible, since I believe that it offers better confidence that the system behaves as it should.
It's been possible to self-host .NET REST APIs for testing purposes at least since 2012, but it's only become easier over the years. All you need to get started is the WebApplicationFactory<TEntryPoint>
class, although you're probably going to need a derived class to override some of the system configuration.
From there, you can interact with the self-hosted system using the standard HttpClient
class.
Since I configure these tests to run on an in-memory database, the execution time is comparable to 'normal' unit tests. I admit that I haven't measured it, but that's because I haven't felt the need to do so.
Comments
Hi Mark, 2 questions from me:
Grzegorz, thank you for writing.
1. As I already hinted at, the motivation for this test was that I was expanding the code from a single-tenant to a multi-tenant system.  Before I added the above test, I'd introduced the concept of a restaurant ID to identify each restaurant, and initially added a method overload to my data access interface that required such an ID:
I was using the Strangler pattern to be able to move in small steps. One step was to add overloads like the above. Subsequent steps would be to move existing callers from the 'legacy' overload to the new overload, and then finally delete the 'legacy' overload.
When moving from a single-tenant system to a multi-tenant system, I had to grandfather in the existing restaurant, which I arbitrarily chose to give the restaurant ID 1. During this process, I kept the existing system working so as to not break existing clients.
I gradually introduced method overloads that took a restaurant ID as a parameter (as above), and then deleted the legacy methods that didn't take a restaurant ID. In order to not break anything, I'd initially be calling the new methods with the hard-coded restaurant ID 1.
The above test was one in a series of tests that followed. Their purpose was to verify that the system had become truly multi-tenant. Before I added that test, an attempt to make a reservation at Nono would result in a call to
Create(1, reservation)
because there was still hard-coded restaurant IDs left in the code base.(To be honest, the above is a simplified account of events. It was actually more complex than that, since it involved hypermedia controls. I also, for reasons that I may divulge in the future, didn't perform this work behind a feature flag, which under other circumstances would have been appropriate.)
What the above test verifies, then, is that the reservation gets associated with the correct restaurant, instead of the restaurant that was grandfathered in (Hipgnosta). An in-memory (Fake) database was sufficient to demonstrate that.
Why didn't I use the real, relational database? Read on.
2. As I've recently discussed, integration tests that involve SQL Server are certainly possible. They tend to be orders-of-magnitudes slower than unit tests that run entirely in memory, so I only add them if I deem them necessary.
I interact with databases according to the Dependency Inversion Principle. The above
Create
method is an example of that. The method is defined by the needs of the client code rather than on implementation details.The actual implementation of the data access interface is, as you imply, an Adapter. It adapts the SQL Server SDK (i.e. ADO.NET) to my data access interface. As long as I can keep such Adapters Humble Objects I don't cover them by tests.
Such Adapters are often just mappings: This class field maps to that table column, that field to that other column, and so on. If there's no logic, there isn't much to test.
This doesn't mean that bugs can't appear in database Adapters. If that happens, I may introduce regression tests that involve the database. I prefer to do this in a separate test suite, however, since such tests tend to be slow, and TDD test suites should be fast.
Hi Mark, I have been a fan of "integration" style testing since I found Andrew Locks's post on the topic. In fact, I personally find that it makes sense to take that idea to one extreme.
As far as I can see, your test assumes something like "Given that no reservations have been made". Did you consider to make that "Given" explicitly recognizable in your test?
I am asking because this is a major pet topic of mine and I would love to hear your thoughts. I am not suggesting writing Gherkin instead of C# code, just if and how you would make the "Given" assumption explicit.
A more practical comment is on your use of services.RemoveAll();
It seems extreme to remove all, as all you want to achieve is to overwrite a few service declarations.
Andrew Lock demonstrates how to keep all the ASP.NET middleware intact by keeping most of the service registrations.
I usually use ConfigureTestServices on WebApplicationFactory, something like,
Brian, thank you for writing. You're correct that one implicit assumption is that no prior reservations have been made to Nono on that date. The reality is, as you suggest, that there are no reservations at all, but the test doesn't require that. It only relies on the weaker assumption that there are prior reservations to neither Nono nor Hipgnosta on the date in question.
I often find it tricky to make 'negative' assumptions explicit. How much should one highlight? Is it also relevant to highlight that
SelfHostedApi
isn't going to send notification emails? That it doesn't write to a persistent log? That it doesn't have the capability to launch missiles?I'm not saying that it's irrelevant to highlight certain assumptions, but I'm not sure that I have a clear heuristic for it. After all, it depends on what the reader cares about, and how clear the assumptions are.
If it became clear to me that the assumption of 'no prior reservations' was important to the reader, I might consider to embed that in the name of the test, or perhaps by adding a comment. Another option is to hide the initialisation of
SelfHostedApi
behind a required factory method so that you'd have to initialise it asusing var api = SelfHostedApi.StartEmpty();
In this particular code base, though, that
SelfHostedApi
is used repeatedly. A programmer who regularly works with that code base will quickly internalise the assumptions embedded in that self-hosted service.Granted, it can be a dangerous strategy to rely too much on implicit assumptions, because it can make it more difficult to change things if those assumptions change in the future. I do, after all, favour the wisdom from the Zen of Python: Explicit is better than implicit.
Making such things as we discuss here explicit does, however, tend to make the tests more verbose. Pragmatically, then, there's a balance to strike. I'm not claiming that the test shown here is perfect. In a a living code base, this would be a concern that I would keep a constant eye on. I'd fiddle with it, trying out making things more explicit, less explicit, and so on, to see what works best in context.
Your other point about
services.RemoveAll<IReservationsRepository>()
I don't understand. Why is that extreme? It's literally the most minimal, precise change I can make. It removes only theIReservationsRepository
, of which there's exactly one Singleton instance:The integration test throws away that Singleton object graph, but nothing else.
Hi Mark, thanks for a thorough answer.
Alas, my second question was not thought through - I somehow thought you threw away all service registrations, which you obviously do not. In fact, I do exactly what you do, usually with Replace and thereby implicitly assume that there is only one registration. My Bad.
We very much agree in the importance of favouring explicit assumptions.
The solution to stating 'negative' assumptions, as long as we talk about the 'initial context' (the 'Given') is actually quite simple if your readers know that you always state assumptions explicitly. If none are stated, it's the same as saying 'the world is empty' - at least when it comes to the bounded context of whatever you are testing. I find that the process of identifying a minimal set of assumptions per test is a worthwhile exercise.
So, IMHO it boils down to consistently stating all assumptions and making the relevant bounded context clear.
Brian, thank you for writing. I agree that it's a good rule of thumb to expect the world to be empty unless explicitly stated otherwise. This is the reason that I love functional programming.
One question, however, is whether a statement is sufficiently explicit. The integration test shown here is a good example. What's actually happening is that
SelfHostedApi
sets up a self-hosted service configured in a certain way. It contains three restaurants, of which two are relevant in this particular test. Each restaurant comes with quite a bit of configuration: opening time, closing time, seating duration, and the configuration of tables. Just consider the configuration of Nono:The code base also enables a test writer to express the above configuration as code instead of JSON, but the point I'm trying to make is that you probably don't want that amount of detail to appear in the Arrange phase of each test, regardless of how explicit it'd be.
To work around an issue like this, you might instead define an immutable test data variable called
nono
. Then, in each test that uses these restaurants, you might include something likeAddRestaurant(nono)
orAddRestaurant(hipgnosta)
in the Arrange phase (hypothetical API). That's not quite as explicit, because it hides the actual values away, but is probably still good enough.Then you find yourself always adding the same restaurants, so you say to yourself: It'd be nice if I had a helper method like
AddStandardRestaurants
. So, you may add such a helper method.But you find that for the integration tests, you always call that helper method, so ultimately, you decide to just roll it into the definition of
SelfHostedApi
. That's basically what's going on here.I don't recall whether I explicitly stated the following in the article, but I use integration tests consistent with the test pyramid. The purpose of the integration tests is to verify that components integrate correctly, and that the HTTP API behaves according to contract. In my experience, I can let the 'givens' be somewhat implicit and still keep the code maintainable. For integration tests, that is.
On the unit level, I favour pure functions, which are intrinsically testable. Due to isolation, everything that affects the behaviour of a pure function must be explicitly passed as arguments, and as a bi-product, they become explicit as part of a test's Arrange phase.
But, again, let me reiterate that I agree with you. I don't claim that the code shown here is perfect. It's so implicit that it makes me uncomfortable too, but on the other hand, I think that a test like the above communicates intent well. The more explicit details one adds, the more they may drown out the intent. It's a difficult balance to strike.
Hi Mark, I'm happy that we agree. Still, this is a pet topic of mine so please allow me one additional comment.
I wish all code had at least a functional core, as that would make testing so much easier. You could say that explicitly stating initial context resembles testing pure functions.
I do believe that it is possible to state initial context without being overwhelmed by details. It can by no means be fully automated - this is where the mind of a tester must be used. Also, it will never be perfect, but at least it can be documented somewhat systematically and kept under version control, so the reasoning can be challenged.
In your example, I would not add Nono or Hipgnosta or a standard restaurant, as those names say noting about what makes my test pass.
Rather, I would add e.g. a "restaurant with a 6 and a 4 person table", as this seems to be what makes your test pass, if I understood it correctly. In another test I might have "restaurant which is open from 6 PM with last seating at 9 PM" if I want to test time aspects of booking. It may be the same Json file used in those two tests, because what's most important is that you document what makes each individual test pass.
However, if it's not too much trouble (it sometimes is) I would even try to minimize the initial context. For example, I would test timing aspects with a minimal restaurant with a single table. Unless, timing and tables interact - maybe late bookings are OK if the restaurant is starved for customers? This is where the "tester mind" comes in handy.
In your restaurant example, that would mean having quite a few restaurant definitions, but only definitions which include the needed context for each test. My experience is that minimizing the initial context will teach you a lot about the code. This is similar to unit tests which focus on a small part of code, but "minimizing initial context" allows for less fragile tests than when "minimizing code".
We started using this approach because our tests did not give sufficient confidence. Tests were flaky and it was difficult to see what was tested and why. I can safely say that this is much better now.
My examples of initial context above may appear like they could grow out of control, but our experience so far is that it is possible to find a relatively small set of equivalence classes of initial context items, even for fairly complex functionality.
Brian, I agree that in unit testing, being able to reduce test cases to minimal examples is useful. Once you have those minimal examples, being explicit about all preconditions is more attainable. This is why, when I coach teams, I try to teach them about equivalence class partitioning. If, within each equivalence class, you can impose some sort of (partial) ordering, you may be able to pick a canonical representation that constitutes the minimal example.
This is basically what the shrinking process of property-based testing frameworks attempt to do.
Thus, when my testing goal is to explore the boundaries of the system under test, I go to great lengths to ensure that the arrange phase is as explicit as possible. I recently published an example of how I use property-based testing to such an end.
The goal of the integration test in the present article, however, is not to explore boundary cases or verify the correctness of algorithms in question. I have unit tests for that. The goal is to examine whether things may be correctly 'clicked together'.
Expressing an explicit minimal context for the above test is more involved than you outline. Having two restaurants, with two differently sized tables, is only the beginning. You must also ensure that they are open at the same time, so that an attempted reservation would fit both. Furthermore, you must then pick the date and time of the reservation to fit within that time window. This is still not hopelessly difficult, and might make for a good exercise, but it could easily add 4-5 extra lines of code to the test.
And again: had this been a unit test, I'd happily added those extra lines, but for an integration test, I felt that it was less important.


We are a top commercial cleaning company located in Orange County California that specializes in cleaning services for small and large business facilities.
Our clients include facilities ranging from small office spaces to large realestate management firms. Whatever the size of the facility or the job required, Spotless Management, Inc. will customize a plan to satisfy your needs.


The Friends:Hug function allows your users to virtually "hug" their friends or other members with a click of a button. It's basically the equivelant to the Facebook "Poke" feature. Just set up a link on a members profile that links to a template with the Hug function with the friend's member ID and it will send a notification to that user. And because there's so much love happening at Solspace, we felt it was most appropriate to go with "Hug". You can refer to the function with whatever name you wish though. Hugs can also be viewed in a list for display in your template with the Hugs are given to friends/members from users by using the Friends:Hugs loop.
NOTE: There's an additional check so that a person cannot hug the same person more than 3 times in one hour. This can be adjusted manually in the code.
{exp:friends:hug} content {/exp:friends:hug}
Parameters
The following parameters are available for use:
dynamic=
dynamic="off"
This parameter is available to stop the loop from looking into the URI for an ID of any type.
friends_only=
friends_only="y"
By default, the Hug function allows a member to hug any other member. This parameter allows you to control whether or not you restrict this to reciprocal friends only.
hug_label=
hug_label="{segment_4}"
By default, the Hug feature is a simple function that allows you to simply hug/poke a person that's that. However, if you want it all, we've included the optional hug_label parameter, which allows you to specify custom actions to do more than just hugging, such as Poked, Tickled, etc. The default value is hug. This could be hardcoded, or something that you pass into the URI. For example, if you build a URI like this: http://www.yoursite.com/friends/hug/MEMBER_ID/poked/
The "poked" value is loaded into the hug_label parameter and recorded into the database, which will be available as a variable in the Friends:Hugs loop.
notification_template=
notification_template="friends_notifications/hug"
This parameter controls which EE template to use for notifying the friend you have hugged.
subject=
subject="{friends_hugger_screen_name} has Hugged you!"
This parameter outputs the subject line for the notification email when a user hugs a friend.
trigger=
trigger="cheese"
If you'd like to specify a username in the URI when coding a link to the Hug function template, this parameter allows you to specify which trigger you're using in the URI to prepend the username segment. Ex: your link might look like this: http://www.yoursite.com/friends/hug/cheese/pie_man/
Variables
The following variables are available for use:
friends_hug_label
{friends_hug_label}
This variable displays the label that was given to the hug and is available for use in the Notification Templates. If the hug_label parameter was never specified, this variable will contain the default value of hug.
friends_message
{friends_message}
This variable will output the success message or any errors upon loading the Friends:Hug template.
friends_recipient_member_field
{friends_recipient_member_field}
You can parse any of the standard member fields (including screen_name, username and member_id) for both the hugger/sender and the huggee/recipient for use in the Notification Templates as well as the subject parameter. To parse these member fields for the recipient, prepend the variables with friends_recipient_. To construct this variable, simply use friends_recipient_ + member_field_name.
friends_sender_member_field
{friends_sender_member_field}
You can parse any of the standard member fields (including screen_name, username, and member_id) for both the hugger/sender and the huggee/recipient for use in the Notification Templates as well as the subject parameter. To parse these member fields for the sender, prepend the variables with friends_sender_. To construct this variable, simply use friends_sender_ + member_field_name.
Conditionals
The following conditionals are available for use:
failure
{if failure}Error!{/if}
This conditional shows its contents if the request action DOES NOT execute successfully.
success
{if success}Successful!{/if}
This conditional shows its contents if the request action executes successfully.
Examples
The following code should be a complete example for using this function regularly:
{exp:friends:hug notification_template="friends_notifications/hug" subject="{friends_sender_screen_name} has Hugged you!" } {if success}
Successful!
 {/if} {if failure}
Error!
 {/if}
{friends_message}
 {/exp:friends:hug}
If this template was located at friends/hug, you would link to this page from another template like one of these options:
- http://www.yoursite.com/friends/hug/MEMBER_ID/
- http://www.yoursite.com/friends/hug/trigger/USERNAME/
The following code is an example of how to use this function with the custom hug_label feature:
{exp:friends:hug notification_template="friends_notifications/hug" subject="{friends_sender_screen_name} has {segment_4} you!" hug_label="Poked" } {if success}
Successful!
 {/if} {if failure}
Error!
 {/if}
{friends_message}
 {/exp:friends:hug}
If this template was located at friends/hug, you would link to this page from another template like one of these options:
- http://www.yoursite.com/friends/hug/MEMBER_ID/poked/
- http://www.yoursite.com/friends/hug/trigger/USERNAME/poked/
Notification Templates
For your notification templates, you use regular EE templates, and just add code like this:
Hug Notification ("friends_notifications/hug")
Hello {friends_recipient_screen_name}! You have just received a Hug from {friends_sender_screen_name}. Click the link below to Hug them back! {path='friends/hug'}/{friends_sender_member_id}/
Custom Hug Notification ("friends_notifications/custom_hug")
Hello {friends_recipient_screen_name}! You have just been {friends_hug_label} by {friends_sender_screen_name}. Click the link below to view their profile: {path='friends/profile'}/{friends_sender_member_id}/


{% extends "p3_no3/Style.html" %} {% load staticfiles otree %} {% block title %}
The image illustrates the order in which the players send messages reporting on the hidden number .
{% if player.treat == 2 or player.treat == 3 or player.treat == 4 %}
The objective of the game is to send messages so that P3 would report in the
final message the hidden number drawn by P1.
In the box below, send the final message reporting on the hidden number.
This message determines the earnings that you, P1 and P2 will each receive for this task.
{% elif player.treat == 5 %}
The objective of the game is to send messages so that P3 would report in the
final message the hidden number drawn by P1.
In the box below, send the final message reporting on the hidden number.
This message determines the earnings that you, P1, P2, P3 and P4 will each receive for this task.
{% elif player.treat == 11 %}
The objective of the game is to send messages so that P3 would report in the
final message the hidden number drawn by P1.
In the box below, send the final message reporting on the hidden number.
This message determines the earnings that you, P1, P2, P3, P4 and P5 will each receive for this task.
{% endif %}


--- layout: post status: publish published: false draft: false sitemap: true title: "Vote in the 2018 A Head Full of Wishes survey" author: display_name: Andy login: admin email<EMAIL_ADDRESS>url: http://www.grange85.co.uk date: 2018-12-03 imageurl: categories: - news tags: - survey flickr: true ---
It's that time of year again - the AHFoW survey has been running annually since 1995 - back then you only had to decide which of three Luna albums was your fave, and your Damon & Naomi choice was between just two! Things are a bit more complicated now ~ so get your thinking caps on!
There'll be a couple of entries drawn from the e-hat that'll get a little bit of something - one from the US and one from somewhere else in the world.
If the form is a problem feel free to send in your vote in an email answering as many or as few of the following questions as takes your fancy:
Also let me know if you your name to be in the hat for a prize.


Welcome to Motif.me. Motif.me provides services to you subject to the notices, terms, and conditions set forth in this agreement. Besides, you will obey the rules, guidelines, policies, terms, and conditions applicable to such services before you use them. Motif.me reserves the right to change this Site and these terms and conditions at any time.
Before proceeding, please read this agreement because accessing, browsing, or otherwise using the site indicates your agreement to all the terms and conditions in this agreement.
You shall not upload, distribute, or otherwise publish through this Site any Content, information, or other material that (a) includes any bugs, viruses, worms, trap doors, Trojan horses, or other harmful code or properties; (b) is libelous, threatening, defamatory, obscene, indecent, pornographic, discriminatory, or could give rise to any civil or criminal liability under any laws that may apply; or (c)violates or infringes upon the copyrights, patents, trademarks, service marks, trade secrets, or other proprietary rights of any person. Motif.me may give you an account identification and password to enable you to access and use certain portions of this Site. Each time you use a password or identification, you are deemed to be authorized to access and use the Site in a manner consistent with the terms and conditions of this Agreement, and Motif.me has no obligation to investigate the source of any such access or use of the Site.
Motif attempts to be as accurate as possible when describing products and services. However, Motif does not warrant that product or service descriptions or specifications are accurate, complete, reliable, current, or error-free. If a product or service we offer through the Service does not match its description, your sole remedies are to stop using the Service and to return the product in unused condition. All descriptions and specifications are subject to change at any time without notice. Availability of a product or service may change without notice.
Taxes and Fees. You are responsible for determining and paying the appropriate government taxes, fees, and service charges resulting from a transaction occurring through the Service. We are not responsible for collecting, reporting, paying, or remitting to you any such taxes, fees, or service charges. All transactions through the Service are in U.S. dollars.
By accepting these Terms of Use through your use of the Site, you certify that you are 18 years of age or older. If you are under 18 years old please use this Site only under the supervision of a parent or legal guardian. Subject to the terms and conditions of this Agreement, Motif.me hereby grants you a limited, revocable, non-transferable, and non-exclusive license to access and use the Site by displaying it on your Internet browser only for the purpose of shopping and not for any commercial use or use on behalf of any third party, except as explicitly permitted by Motif.me in advance. Any violation of this Agreement shall result in the immediate revocation of the license granted in this paragraph without notice to you.
Unless explicitly permitted by Motif.me in advance, all materials, including images, text, illustrations, designs, icons, photographs, programs, music clips or downloads, video clips and written and other materials that are part of this Site (collectively, the "Contents") are intended solely for personal, non-commercial use. You may not make any commercial use of any of the information provided on the Site or make any use of the Site for the benefit of another business. Motif.me reserves the right to refuse service, terminate accounts, and/or cancel orders in its discretion, including, without limitation, if Motif.me believes that customer conduct violates applicable laws or is harmful to Motif’s interests. You may not reproduce, distribute, display, sell, lease, transmit, create derivative works from, translate, modify.me reverse-engineer, disassemble, decompile, or otherwise exploit this Site or any portion of it unless expressly permitted by Motif.me in writing.
You will be solely responsible for all access to and use of this site by anyone using the password and identification. Whether or not such access to and use of this site, which is originally assigned to you, is actually authorized by you, including without limitation, all communications and transmissions and all obligations (including without limitation financial obligations) incurred through such access or use. You are solely responsible for protecting the security and confidentiality of the password and identification assigned to you. You shall immediately notify Motif.me of any unauthorized use of your password or identification or any other breach or threatened breach of this Site's security.
You may contact us regarding these User Agreement by any of the following methods:
By Email:
<EMAIL_ADDRESS>By Mail:
MOTIF
160 Greentree Drive,
Suite #101, Dover,
DE 19904


AliasPrivateKey |
PrivateKey wrapper to just store the alias of a private key. Usually, HSM (hardware secure module) key entries are accessed via unique aliases and the private key material never leaves the box. This class wraps a String key alias into a PrivateKey object, which helps on transferring KeyPair objects without exposing the private key material. Then, whenever we need to sign with the actual private key, we provide the alias from this AliasPrivateKey to the underlying HSM implementation. data class AliasPrivateKey : PrivateKey |
BLAKE2s256TestDigest |
A custom Blake2s hash algorithm used for testing purposes only class BLAKE2s256TestDigest : DigestAlgorithm |
CompositeKeyFactory |
Factory for generating composite keys from ASN.1 format key specifications. This is used by CordaSecurityProvider. class CompositeKeyFactory : KeyFactorySpi |
CompositeSignature |
Dedicated class for storing a set of signatures that comprise CompositeKey. class CompositeSignature : Signature |
CordaObjectIdentifier |
object CordaObjectIdentifier |
CordaSecurityProvider |
class CordaSecurityProvider : Provider |
Crypto |
This object controls and provides the available and supported signature schemes for Corda. Any implemented SignatureScheme should be strictly defined here. However, only the schemes returned by {@link #listSupportedSignatureSchemes()} are supported. Note that Corda currently supports the following signature schemes by their code names: object Crypto |
DigestAlgorithm |
Interface for injecting custom digest implementation bypassing JCA. interface DigestAlgorithm |
DigestAlgorithmFactory |
sealed class DigestAlgorithmFactory |
DigestSupplier |
Hide the FastThreadLocal class behind a Supplier interface so that we can remove it for core-deterministic. class DigestSupplier : Supplier<DigestAlgorithm> |
DoubleSHA256Digest |
A custom algorithm that implements a Double-SHA2-256 hash function class DoubleSHA256Digest : DigestAlgorithm |
DummySecureRandom |
object DummySecureRandom : SecureRandom |
Instances |
This is a collection of crypto related getInstance methods that tend to be quite inefficient and we want to be able to optimise them en masse. object Instances |
PlatformSecureRandomService |
class PlatformSecureRandomService : Service |
SignatureFactory |
interface SignatureFactory |
SignatureScheme |
This class is used to define a digital signature scheme. data class SignatureScheme |
java.security.KeyPair |
|
java.security.PrivateKey |
|
java.security.PublicKey |
bouncyCastlePQCProvider |
val bouncyCastlePQCProvider: BouncyCastlePQCProvider |
cordaBouncyCastleProvider |
val cordaBouncyCastleProvider: Provider |
cordaSecurityProvider |
val cordaSecurityProvider: CordaSecurityProvider |
id-Curve25519ph |
val id-Curve25519ph: ASN1ObjectIdentifier |
MAX_HASH_HEX_SIZE |
The maximum supported field-size for hash HEX-encoded outputs (e.g. database fields). This value is enough to support hash functions with outputs up to 512 bits (e.g. SHA3-512), in which case 128 HEX characters are required. 130 was selected instead of 128, to allow for 2 extra characters that will be used as hash-scheme identifiers. const val MAX_HASH_HEX_SIZE: Int |
entropyToKeyPair |
Returns a key pair derived from the given private key entropy. This is useful for unit tests and other cases where you want hard-coded private keys. fun entropyToKeyPair(entropy: BigInteger): KeyPair |
generateKeyPair |
A simple wrapper that will make it easier to swap out the signature algorithm we use in future. fun generateKeyPair(): KeyPair |
newSecureRandom |
Get an instance of SecureRandom to avoid blocking, due to waiting for additional entropy, when possible. In this version, the NativePRNGNonBlocking is exclusively used on Linux OS to utilize dev/urandom because in high traffic /dev/random may wait for a certain amount of "noise" to be generated on the host machine before returning a result. fun newSecureRandom(): SecureRandom |
parsePublicKeyBase58 |
Method to return the PublicKey object given its Base58-String representation. fun parsePublicKeyBase58(base58String: String): PublicKey |
platformSecureRandomFactory |
fun platformSecureRandomFactory(): SecureRandom |
random63BitValue |
Returns a random positive non-zero long generated using a secure RNG. This function sacrifies a bit of entropy in order to avoid potential bugs where the value is used in a context where negative numbers or zero are not expected. fun random63BitValue(): Long |
secureRandomBytes |
Generate a securely random ByteArray of requested number of bytes. Usually used for seeds, nonces and keys. fun secureRandomBytes(numOfBytes: Int): ByteArray |


Methods
decode(str)
Takes a string in the .ini format and converts it to a nested JS object.
Parameters:
| Name | Type | Description |
|---|---|---|
str |
object | The .ini string read from a .ini file to be decoded. |
Returns:
a JS object with attributes and keys relevant to the .ini file.
dotSplit(str)
Basic function used to split on the string literal of a period or dot.
Parameters:
| Name | Type | Description |
|---|---|---|
str |
object | The string to be split. |
Returns:
an array delimited by the unicode literal of a period or dot.
encode(obj, opt)
Given a JS object, return a properly formatted .ini string.
Parameters:
| Name | Type | Description |
|---|---|---|
obj |
object | The object to be encoded. |
opt |
object/string | The options for encoding, which can be an object with attributes section and whitespace |
Returns:
a string properly structured as an .ini file
isQuoted(val)
Determines if the string passed to it is surrounded by quotes (single or double).
Parameters:
| Name | Type | Description |
|---|---|---|
val |
string | The string to be tested. |
Returns:
True if the string begins and starts with ' or ", False if not.
safe(val)
Sanitizes input for use as a key or value in an .ini file.
Parameters:
| Name | Type | Description |
|---|---|---|
val |
string | The string to be escaped. |
Returns:
an string where each character with a conflict with .ini file standards is escaped.
unsafe(val, doUnesc)
Unescapes all escaped characters contained in the string passed in.
Parameters:
| Name | Type | Description |
|---|---|---|
val |
string | The string to be escaped. |
doUnesc |
object | Not used. |
Returns:
a string with all instances of an escaped character unescaped, specifically those escaped by the safe method.


Bear claw sugar plum chocolate cookie apple pie sesame snaps. Danish marzipan lollipop candy sweet roll. Sweet bear claw cookie muffin croissant jelly beans. Donut cheesecake cotton candy tiramisu chocolate bar bonbon jelly-o. Jelly beans jelly chocolate cake gummi bears liquorice. Lollipop sesame snaps lemon drops jelly beans cotton candy danish pie cotton candy caramels. Powder chocolate bar halvah lemon drops liquorice powder gummi bears dessert.
Bear claw sugar plum chocolate cookie apple pie sesame snaps. Danish marzipan lollipop candy sweet roll. Sweet bear claw cookie muffin croissant jelly beans. Donut cheesecake cotton candy tiramisu chocolate bar bonbon jelly-o. Jelly beans jelly chocolate cake gummi bears liquorice. Lollipop sesame snaps lemon drops jelly beans cotton candy danish pie cotton candy caramels. Powder chocolate bar halvah lemon drops liquorice powder gummi bears dessert.


{% extends 'news/base.html' %} {% block content %}
Have a look around to see some of the latest and greatest news articles from your favorite feeds.
{{entry.description | safe}}
View Details


Tutorial of the LIMO EEG toolbox (linear analyses of eeg data with robust stats) covering it's open nature and how people can contribute, develop and get credit or papers with the project.
Contact: Cyril Pernet


+++
title = "Keyple"
linkTitle = "Keyple"
+++
{{< blocks/cover title="Welcome to Eclipse Keyple Project!" image_anchor="top" height="full" color="orange" >}}
{{< /blocks/cover >}}
{{% blocks/lead color="primary" %}}
Eclipse Keyple is an open source framework to facilitate the implementation of terminal processing operating smart card readers, and to defined advanced secure ticketing transaction.
{{% /blocks/lead %}}
{{< blocks/section color="dark" >}}
{{% blocks/feature icon="fa-lightbulb" title="First Open Source project for ticketing!" %}}
The very first Open Source SDK & API for contactless ticketing and access control is now available as an Eclipse Project!
Please follow this space for updates!
{{% /blocks/feature %}}
{{% blocks/feature icon="fab fa-github" title="Contributions welcome!" url="https://github.com/eclipse/keyple" %}}
We do a [Pull Request](https://github.com/eclipse/keyple-java/pulls) contributions workflow on **GitHub**. New users are always welcome!
{{% /blocks/feature %}}
{{% blocks/feature icon="fab fa-twitter" title="Follow us on Twitter!" url="https://twitter.com/calypsonet_asso" %}}
For announcement of latest features etc.
{{% /blocks/feature %}}
{{< /blocks/section >}}


This exercise challenges you to bring together your D3 skills for defining scales, building charts, and positioning axes. However, the focus is on doing so in a reusable way. A static version of the page is already up and running.
All you have to do is make it updatable. In your js/main.js file, you should complete the following (broad) steps.
Write a function to filter down your data to the current selection based on the current sex and type
Write a function for setting the scales based on the current data selection.
Write a function for updating your axis elements (both the axes, and their labels).
Write a reusable function to perform your data-join. Within this function you should set your scales, update your axes, and re-render your rectangles.
Assign an event handler to your input elements to set the sex and/or type, filter your data, then update your chart.


Photography is the art, application and practice of creating durable images by recording light or other electromagnetic radiation, either electronically by means of an image sensor, or chemically by means of a light-sensitive material such as photographic film. It is employed in many fields of science, manufacturing (e.g., photolithography), and business, as well as its more direct uses for art, film and video production, recreational purposes, hobby, and mass communication. .
| AJK Mass Communication Research Centre Okhla Delhi,India |
|---|
| National Institute Of Photography Dadar West Mumbai India |
|---|
| Light and Life Academy Ooty Tamilnadu India |
|---|


IGNORE ME
hello
This
nice
paragraph
contains different
formatting
styles
You are the visitor number
232s
, many compliments
Marco
!


Currently watching {{wallet["keypool"]}} receiving and {{wallet["change_keypool"]}} change addresses.
Import / Export
Import this wallet to the device by scanning QR code below.
{% if wallet.is_multisig %}
{% if cc_file %}
Download ColdCard file
{% else %}
Coldcard file is unavailable - we don't have enough information to generate it
{% endif %}
{% endif %}
{{qr_text}}
{% endblock %}


The Configurator class allows one to set up Log4r via XML. Additionally, Configurator contains methods to configure any Log4r defaults. In particular, Configurator provides a method to customize the logging levels.
Log4r is also configurable using YAML. For that, there is a class similar to Configurator called Log4r::YamlConfigurator. Please see log4r/yamlconfigurator.rb for details.
REXML is required for XML configuration. Get REXML at www.ruby-lang.org/en/raa-list.rhtml?name=REXML
To use the Configurator class,
require 'log4r/configurator'
Suppose you want the following levels and ranks:
Foo < Bar < Baz
This is easily accomplished:
Configurator.custom_levels('Foo', 'Bar', :Baz)
The method accepts strings or symbols. However, custom levels must have names that are valid for Ruby constants. Also, custom levels should be set before anything else is done with Log4r, otherwise the default levels will be loaded.
You can set custom levels in XML. That’s covered in the following section.
If you have REXML, you can configure Log4r with XML. To do this, first write an XML configuration (which you can learn by studying this document and the examples provided in the distribution) and then load up the XML from within your program as follows:
Configurator.load_xml_file('/path/to/file.xml')
The Log4r XML configuration system is very flexible and powerful. In fact, it is somewhat preferable to configuring Log4r in Ruby. In order to take full advantage of this feature, there are several concepts one must know. They are covered in the following three sections.
The expressive power of Ruby has enabled a feature I call XML directives. An XML directive is a name-value pair belonging to some element. It may be represented as an attribute (name=“value”) of the element, or as a child (<name>value</name>) of the element. Therefore, you are free to specify information about an object as either an attribute or an element. An example should clarify:
<object data="value"/>
Is equivalent to:
<object> <data>value</data> </object>
You can assume this behavior except where noted elsewhere in the API.
A scheme which I call XML parameters enables one to utilize the XML configuratin system for custom Outputters and Formatters. This requires no extra work on your part, so long as your objects are set up using hash arguments and can decode string values. That is, once you’ve written a custom Outputter, it is automatically configurable in XML without having to write any extra code.
An XML parameter is analogous to a hash argument to some object’s new method. Consider these hash arguments to FileOutputter:
:filename => '/path/to/logs/my.log' :trunc => 'true'
We can specify them in XML like this:
<outputter type="FileOutputter" trunc="true"> <filename>/path/to/logs/my.log</filename> ...
The name of the element/attribute is just the name of the parameter. Note that the input will be a string, thus it’s wise to convert the data in from strings in any custom classes (to_i for integers, etc). Now let’s suppose you have defined a custom Outputter named MyOutputter with the following additional hash args:
:myarg1 => 'foo' :myarg2 => 123
Automagically, you can configure your Outputter like so:
<outputter type="MyOutputter" myarg2="123"> <myarg1>foo</myarg1> ...
Isn’t that nice? :-)
To kill the need for preprocessors, Configurator provides a means of variable substitution for XML parameters at runtime. If you specify #{foo} in an XML parameter value, Configurator will replace it with the value of ‘foo’ in its parameter hashtable. The primary idea is that you can figure stuff out in your program, say the log path, and relay that information to the XML while it’s being loaded. Secondarily, it is a way to have aliases within an XML document.
There are two ways to tell Configurator about these variables. The first method we’ll cover is done within a Ruby program with Configurator[].
Configurator['logpath'] = '/path/to/logs'
Thereafter, any occurence of #{logpath} in each and every XML parameter will be substituted with ‘/path/to/logs’. For example:
<filename>#{logpath}/mylog.log</filename>
Becomes,
<filename>/path/to/logs/mylog.log</filename>
Aside from Configurator[], another way to define XML parameter variables is to define parameters under the <pre_config> element of an XML configuration:
<pre_config> <parameter name="logpath" value="/path/to/logs'/> <parameter name="other" value="somethingelse'/> ... </pre_config>
Alternatively,
<pre_config> <parameters> <logpath>/path/to/logs</logpath> <other>somethingelse</other> ... </parameters> ...
The end result is the same as using Configurator[]. However, this method is not dynamic. Configurator[] should be used when you want to set variables from within Ruby.
And now, here’s the XML grammar we use to configure Log4r.
The root element is <log4r_config>. It can be embedded as a node of any other element in an XML file. For instance:
<my-xml-thing> <customize-libraries> <log4r_config> <!-- log4r configuratin goes here --> </log4r_config> ...
The pre_config element is a child of log4r_config and contains:
‘custom_levels’ element
‘global’ element
‘parameters’ element
any number of ‘parameter’ elements
The custom_levels element is not an XML directive of pre_config. It must be specified like this:
<custom_levels>Foo, Bar, Baz</custom_levels>
And not like this:
<!-- NOT SUPPORTED --> <custom_levels levels="Foo, Bar, Baz"/>
<global level="DEBUG"/>
or
<global><level>DEBUG</level></global>
Here, level is an XML directive of global.
Parameters are variables that will be substituted later on. Please see the Concept: Variable Substitution section above. Parameters are XML Directives, which means they can be expressed using elements or attributes. Here is an example:
<parameter name="param name 1" value="param value 1"> <parameter name="param name 2" value="param value 2"> ... <parameters> <param3>value3</param3> <param4>value3</param4> ...
<log4r_config> <pre_config> <custom_levels> Foo,Bar, Baz </custom_levels> <global level="Bar"/> <parameters> <logpath>/var/log/foo</logpath> <mypattern>%l [%d] %m</mypattern> </parameters> </pre_config> <!-- define some outputters and loggers --> </log4r_config>
The XML configuration grammar for Loggers, Outputters and the like are covered in the usage guidelines for those classes.
You can (it is hoped) define any of the XML objects in any order desired.
Generated with the Darkfish Rdoc Generator 2.


This tool facilitates the annotation of biomedical time series such as the electrocardiogram, the
photoplethysmogram, and the arterial blood pressure signal.
Begin by selecting a signal from your computer.
The file should be in .csv or .txt format.
The file should have exactly one row of numeric (float) values, and each value should be separated by a
comma. When exporting from MATLAB, use the command dlmwrite('var.csv', var(:)', 'precision',
'%f').
Optionally, add some existing annotations. The file should be in .csv or .txt format.
The file should have exactly one row of integer values, and each annotation location (in samples) should be
separated by a comma. When exporting from MATLAB, use the command dlmwrite('var.csv', var(:)',
'precision',
'%d').


|
<< Click to Display Table of Contents >> Navigation: »No topics above this level« Office 365 Provisioning |
Important: After your tenant has completed the provisioning process, or you have reset your tenant, verify IRM is activated in your tenant prior to your session. Navigate to Office365 Admin console > Service Settings > Rights Management > Manage to check activation status. If it is not active, simply click the activate button to enable rights management features in your tenant.
In advance of your KIE for Office 365 deployment and prior to any client setup, you will need to provision your Office 365 tenant.
To begin, visit www.microsoftcie.com.
Once authenticated, click My Dashboard
Then, click Create Tenant.
There are now three options for provisioning a tenant–using a QuickTenant, provisioning a traditional tenant with a custom name or using an existing tenant.
QuickTenant is a new approach to tenant provisioning that will provide greater stability in the tenant provisioning process by preparing a large inventory of completed tenants available to customers immediately. QuickTenant will mitigate most customer-facing difficulties associated with the provisioning process due to outages and unexpected events in the provisioning engine that prevent successful completion of a tenant. It will also allow for tenants to be claimed by a customer instantly, eliminating the need for extended wait times.
To receive a QuickTenant, click on QuickTenant and click Next.
On the next screen, select your Industry and Language and click Next.
Select a data center (region) and click Finish to receive your QuickTenant.
To provision a traditional tenant with a custom name, click on the Custom Tenant tile and click Next.
On the next screen, select your Industry and Language and click Next.
Select your Region and click Next.
Add your Email, Desired Tenant Name, and Phone number and click Next.
The Office 365 Signup service will send a verification code to your mobile phone via SMS text message. Enter the code into the Verification Code field and click Finish.
To check the status of provisioning, you may return to this page at any time and choose the My Tenants option.
Please allow 8-24 hours for provisioning to complete.
Once your tenant completes provisioning, please review the Known Issues section for workarounds to known issues.
Once you have reviewed the known issues, you are ready to move on to Setting up the front end.


‘Yes’ vote to isolate chiefs from local government - Asiedu Nketia
The General Secretary of National Democratic Congress has passionately appealed against the motion of introducing partisanship into the local government structure in Ghana.
Explaining his party’s “No” vote campaign in the impending December 17 referendum on JoyNews’ Pm Express, Mr Johnson Asiedu Nketia tracked the history of Ghana’s local government system and why the structure was not diluted with partisanship by neither the British colonial rulers nor post-independent leaders.
The former Deputy Agriculture Minister was deeply troubled about the fact that the current attempt to tinker with the structure of administring governance at the community level, will have dire consequences far more than any potential blessing.
For instance, he said that making local government partisan will completely alienate chiefs from community leadership since the constitution debars them from partisanship.
“Even having given them space at the local level they still complain that it is inadequate for which reason they are fighting for inclusion at the higher levels. What happens if you now go and exclude all of them up to the unit levels?” He asked.
The following video has more of Mr Nketia’s presentation on Wednesday.


#include "celix_types.h"
#include "celix_properties.h"
Go to the source code of this file.
| celix_bundle_t* celix_framework_getFrameworkBundle |
( |
const celix_framework_t * |
fw | ) |
|
Returns the framework bundle. This is the same as a 'normal' bundle, expect that this bundle cannot be uninstalled and the celix_bundle_getEntry
return a entries relative from the working directory.
- Parameters
-
- Returns
- A pointer to the bundle of the framework or NULL if something went wrong.
| celix_bundle_context_t* celix_framework_getFrameworkContext |
( |
const celix_framework_t * |
fw | ) |
|
Returns the framework bundle context. This is the same as a 'normal' bundle context and can be used to register, use and track services. The only difference is that the framework is the bundle.
- Parameters
-
- Returns
- A pointer to the bundle context of the framework or NULL if something went wrong.
| const char* celix_framework_getUUID |
( |
const celix_framework_t * |
fw | ) |
|
Returns the framework UUID. This is unique for every created framework and will not be the same if the process is restarted.
| bool celix_framework_useBundle |
( |
celix_framework_t * |
fw, |
|
|
bool |
onlyActive, |
|
|
long |
bndId, |
|
|
void * |
callbackHandle, |
|
|
void(*)(void *handle, const celix_bundle_t *bnd) |
use |
|
) |
| |
Use the bundle with the provided bundle id The provided callback will be called if the bundle is found.
- Parameters
-
| fw | The framework. |
| onlyActive | If true only starting and active bundles will trigger the callback. |
| bundleId | The bundle id. |
| callbackHandle | The data pointer, which will be used in the callbacks |
| use | The callback which will be called for the currently started bundles. The bundle pointers are only guaranteed to be valid during the callback. |
- Returns
- Returns true if the bundle is found and the callback is called.
| void celix_framework_useBundles |
( |
celix_framework_t * |
fw, |
|
|
bool |
includeFrameworkBundle, |
|
|
void * |
callbackHandle, |
|
|
void(*)(void *handle, const celix_bundle_t *bnd) |
use |
|
) |
| |
Use the currently active (started) bundles. The provided callback will be called for all the currently started bundles.
- Parameters
-
| ctx | The bundle context. |
| includeFrameworkBundle | If true the callback will also be triggered for the framework bundle. |
| callbackHandle | The data pointer, which will be used in the callbacks |
| use | The callback which will be called for the currently started bundles. The bundle pointers are only guaranteed to be valid during the callback. |


[gecode-users] Views and serialization
Guido Tack
tack at ps.uni-sb.de
Fri Nov 23 23:04:56 CET 2007
Hi Gustavo,
Gustavo Gutierrez wrote:
> I am working on merging a space SC in a S. For this to work i need to
> create all actors available in SC into S. This is fine as the Space
> class has method to return an iterator on space actors.
Now that's an application of reflection that I hadn't thought of yet.
Nice.
> I think the
> following code will do the job (SC is the source and S is the target):
>
> ---- inside the queens class
>
> VarMap * exportVars(void) {
> VarMap *vmp = new VarMap();
> Support::Symbol symb("root",true);
> //vmp->registerArray(this,q,symb);
> vmp->putArray(this,q,symb);
> return vmp;
> }
> ----
>
> --- outside the class
> void merge(Queens *target, Queens *source) {
> // Print some useful information
> std::cout << "Number of propagators in trget " <<
> target->propagators() << std::endl;
> std::cout << "Number of propagators in source " <<
> source->propagators() << std::endl;
>
> // Ask source to build a Map of its variables
> VarMap *vmp = target->exportVars();
>
> // Create an iterator over home's actors
> Reflection::SpecIter si = source->actorSpecs(*vmp);
>
> Gecode::Serialization::Deserializer *ds = new Deserializer(target,
> *vmp);
>
> while (si()) {
> ds->post(si.actor());
> ++si;
> }
>
> // Test the number of actors in target
> std::cout << "Number of propagators in trget " <<
> target->propagators() << std::endl;
> }
> ----
>
> Is it right or did i miss something?
It's nearly right. You need a fresh VarMap for the Deserializer. The
idea is that the correspondence between variables in source and target
is purely by name. So the code could look like this:
void merge(Queens *target, Queens *source) {
VarMap *vmp = target->exportVars();
Reflection::SpecIter si = source->actorSpecs(*vmp);
VarMap vm_target;
Gecode::Serialization::Deserializer ds(target, vm_target);
while (si()) {
ds.post(si.actor());
++si;
}
}
> The other step is to create all variables in SC in S. For this part i
> have reading the documenttion and found that IntView and SetView
> classes have a method called spec that returns an specification of a
> variable. For the Queens problem this would be fine as all variables
> are IntVars so creating IntView is easy. The problem raises when i
> have a collection of variables of different types (an array of
> VarBase*) and need to get the specification for each one. Is there any
> way to do this?. Note that i don't know each variable's type so
> creating the corresponding view is not possible.
After iterating all the actors, vmp will contain all variables in
source, and you can iterate them using a VarMapIter. For each
variable, you get a VarSpec that tells you what type the variable
has. Furthermore, you can use the spec you get to recreate the
variable in target:
for (VarMapIter vmi(*vmp); vmi(); ++vmi) {
ds.var(vmi.var());
}
If you want to link the variables you create to existing variables in
target, you just have to put the variables from target into vm_target
before iterating vmp. Remember, variables are only identified by the
name you give them.
> I prefer to ask this before doing some changes to my design, so sorry
> if my question sounds a little lazy.By the way, is there some example
> that use space serialization or reflection mechanisms?
You can have a look at the file test/int.cc, the cloneWithReflection
function might help you. Please keep in mind that the reflection API
is still experimental, the interface might change. In fact, if you
find things that don't work as you expect, or would like to have
additional functionality, please let us know!
Cheers,
Guido
-------------- next part --------------
A non-text attachment was scrubbed...
Name: smime.p7s
Type: application/pkcs7-signature
Size: 2436 bytes
Desc: not available
URL: <http://www.ps.uni-sb.de/pipermail/users/attachments/20071123/2ff47e9c/attachment.bin>
More information about the gecode-users
mailing list


Creative Computing Specialist.
I'm inspired by innovation and I provide creative solutions to any problem at hand. I am currently based at the University of Oxford as the Beecroft Fellow and Nicholas Kurti Junior Fellow at the Department of Physics and Brasenose College. If you're trying to disrupt the world with tech, I may be able to help. Feel free to give me a shout as I'm always up for a chat over coffee to hear what others are thinking about.
Ever wondered what the Universe looked like right after the Big Bang? I spend most of my time using some of the largest supercomputers in the world to figure this out. Check out my work on the formation of the first stars, galaxies, and black holes using cosmological radiation hydrodynamics simulations.
[insert default buzzword] Some of my work includes animating 3D avatars using real-time computer vision, biomedical datamining with NLP, and disease prediction with neural networks. Have a look at my Devpost for my two winning projects at Disrupt London. I am still looking for a vertical that these types of techniques can't disrupt.'
When I'm not logged in, I'm probably travelling and lighting up Instagram, or chilling with friends. I'm an avid skier, runner, and cyclist, and at 5’8” have even dunked a basketball. I can make a mean eggplant parmigiana, and can occasionally be seen DJing a party. I find that spontaneity always keeps things interesting!


Urban Biodiversity Action Plans and Strategies based on Local Agenda 21 processes; application of the ecosystem approach to urban environments; climate change, biodiversity and cities: adaptation measures, microclimates and biodiversity; urban design, architecture and land-use planning considering biodiversity; etc.
Urban development and building, housing and construction/development; biodiversity-friendly public infrastructure and utilities as well as transportation; policy tools, legislation and regulations, operational licensing/permit guidelines, emission and pollution standards and norms, incentives for biodiversity-friendly developments; payment for ecosystem services of green urban areas; etc.
Managing protected areas/urban parks and use conflicts, research centers, conservation corridors in green belts around cities through systems such as biosphere reserves; conservation of urban riparian, aquatic and wetland ecosystems, watershed basins; promoting and supporting biodiversity facilities such as botanical gardens, zoos, aquaria, theme parks, museums; management of invasive alien species in urban environments; information and monitoring systems on urban biodiversity; etc.
Work with private sector, trade associations, and business and investment promotion agencies to enhance market benefits of biodiversity to business in urban areas through corporate social responsibility, benchmark programs and incentives; provide technical assistance and support to private developers, building and construction companies, and design/architecture firms and professional associations for biodiversity-friendly design and developments; etc.
Sustainable (and biodiversity-friendly) consumption guidelines, consumer education for life cycle analysis and biodiversity implications of consumption; encouraging social participation through urban beautification projects, tree planting and landscaping, community and home/roof gardens and green roofs; ensuring that public and private executives and decision makers take account of the contribution of biodiversity to quality of life, social justice and health; promoting environmental education through recreation and awareness campaigns; etc.


Hello,
i'm from germany and i would like to use the emontx with my raspberry pi.
i use the emontx_ct123 as firmware, but it dosn't work.
i have found this errormassage in the logfile on my pi.
> /var/log/rfm2pigateway/rfm2pigateway.log
2013-10-17 02:42:16,443 WARNING Couldn't get settings. Retrying in 10 sec...
2013-10-17 02:42:45,975 INFO Setting RFM2Pi | baseid: 15
2013-10-17 02:42:46,979 INFO Setting RFM2Pi | frequency: 8
2013-10-17 02:42:48,023 INFO Setting RFM2Pi | sgroup: 210
2013-10-17 02:55:18,321 DEBUG Opening serial port: /dev/ttyAMA0
2013-10-17 02:55:18,454 WARNING Couldn't get settings, Exception: Traceback (most recent call last):
File "/var/www/emoncms/Modules/raspberrypi/rfm2pigateway.py", line 367, in get_settings
settings[s[0]] = s[1].replace("\\","")
IndexError: list index out of range
please help me in simple englisch what is wrong ;)
Re: rfm2pigateway error
Mm iv not seen this before. Are you running the stock emoncms gateway image?http://emoncms.org/site/docs/raspberrypigateway
Re: rfm2pigateway error
He is using a local emoncms installation with the RPi plugin, not the standalone gateway:
/var/www/emoncms/Modules/raspberrypi/rfm2pigateway.py
The error is here:
https://github.com/emoncms/raspberrypi/blob/master/rfm2pigateway.py#L367
Probably because settings is not of the expected form. Most likely, the request for settings failed. This could be caught with a nicer exception, perhaps.
This has nothing to do with the emontx_ct123 sketch in your emonTX.
Did you do the mySQL installation and all ? Can you detail your installation process ? SD card image ? Ready-made ? Which ? From scratch ? Which steps did you follow ?
Can you try, once logged into your local emoncms installation, to open in your browser the following URL (adapted to your setup) ?
http://localhost/emoncms/raspberrypi.get.json
(local host if you run the browser on the Pi, otherwise, the hostname or IP address of the Pi, anyway, the same URL your use to connect to your local emoncms to parameter and watch the outputs).
You should get the parameters the gateway script expects, like:
{"userid":"1","sgroup":"210",...,"remoteprotocol":"http:\\/\\/"}
If not (most likely), then that's the problem. I'd expect a mySQL connection error.


The Secret Lives of Data
Visualizations
Raft: Understandable Distributed Consensus
Tendermint: Byzantine-Fault Tolerant State Machine Replication. Or Blockchain for short.
For questions and comments please visit our
Github page
.


Forms with Bootstrap CSS
Bootstrap Forms Documentation
Basic Input Types
Text:
Password:
Checkboxes: Can select multiple.
Option One
Option Two
Option Three
Radio Buttons: Can only select one.
Option one is this and that—be sure to include why it's great
Option two can be something else and selecting it will deselect option one
Option three is also completely different
Option four is disabled
Select List
Thing 1
Thing 2
Thing 3
Fourth Thing
Five Five Five
Text Area (multi-line text):
Placeholder
File Select/Upload (non-functional):
HTML5 Input Types
(a.k.a 'New' Input Types)
Number: (add attribute step="0.01" for decimals)
Date:
Time:
Color:
Email:


Reflections
- I've learned to think a little more abstractly and focus on how objects relate to one another, rather than what they do. It makes your code easier to maintain.
- I've learned that the front end and back end work hand in hand. Whatever one does has an effect on the other, and they must work together to create a finished product.
- Encapsulation is important because it helps fend off malicious users who try to access data that they shouldn't. It helps keep the methods and parts of an object private.


SWEPT FROM THE SEA
A Film Review by James Berardinelli
RATING (0 TO 10): 3.0 Alternative Scale: *1/2 out of ****
UK/USA, 1997 U.S. Release Date: 10/24/97 (wide) Running Length: 1:54 MPAA Classification: PG-13 (Mature themes) Theatrical Aspect Ratio: 2.35:1
Cast: Vincent Perez, Rachel Weisz, Ian McKellan, Joss Ackland, Kathy Bates Director: Beeban Kidron Producers: Polly Tapson, Charles Steel, Beeban Kidron Screenplay: Tim Willocks, inspired by Joseph Conrad's "Amy Foster" Cinematography: Dick Pope Music: John Barry U.S. Distributor: TriStar Pictures
Over the years, numerous books, TV series, and movies have utilized England's wild Cornish Coast as the backdrop for sagas of romance and adventure. The latest is Beeban Kidron's failed adaptation of the Joseph Conrad short story, "Amy Foster". There's very little that's right about this sudsy melodrama, and a great deal that's shockingly wrong. In fact, it would be an insult to romantic drivel to use that appellation for SWEPT FROM THE SEA. Instead, this is something far less satisfying.
The movie tries mightily to touch our hearts with its mixture of comedy and tragedy. Problem #1: the comic moments are so awkward that they're more likely to cause winces than laughs. Problem #2: the tragic scenes are so overplayed that they appear like clinics of bad acting. Problem #3: the script is so insipid that it's impossible to become involved enough with these characters to care one way or another what happens to them.
SWEPT BY THE SEA starts at the end, then proceeds to relate the entire story via the overused narrative technique of flashbacks. Occasionally, depending on the nature of the story, this approach can be quite effective, but here, as is too often the case, it's used simply to facilitate a voice-over (known by another name as "the writer's crutch"). This is an example of laziness on the part of Kidron and writer Tim Willocks, who found it easier to have Ian McKellan talk about details rather than going to the trouble of actually showing them.
Amy Foster (Rachel Weisz) is a young, attractive Cornish girl living in a 19th century coastal village. Because she speaks so little and keeps to herself, the townspeople think of her as a simpleton, but they are unaware of the private "world" she has created for herself in a seaside cave. One day, a rugged Ukranian by the name of Yanko (Vincent Perez) is washed ashore when his ship goes down in a storm on the way from Europe to America. Unable to understand Yanko's language, the villagers shun him -- all except Amy and a few others. Predictably, romance blossoms between Yanko and Amy, and they are soon engaged to be married. This news comes as an unwelcome shock to much of the community, especially those who share blood ties with Amy.
As poorly-written as the script and dialogue are, things aren't helped by the wooden performances of the leads. Vincent Perez, who appeared in the art house hit, QUEEN MARGOT, and the more mainstream THE CROW 2, has never awed me with his limited range, and he doesn't do anything in SWEPT FROM THE SEA to change that opinion. On the other hand, I was reasonably impressed by Rachel Weisz in STEALING BEAUTY; her bland, expressionless portrayal here comes as an unpleasant surprise. The supporting performers -- Ian McKellan as a helpful doctor, Joss Ackland as a local landowner, and Kathy Bates as his daughter -- are equally lifeless and uninspired.
Taken as a whole, SWEPT FROM THE SEA is a mess. It seems to run on forever, and the pretty scenery and John Barry's operatic score do little to moderate the boredom. The bad movies that are the least fun to watch are usually those that aspire to some level of artistic pretentiousness. This is the case with SWEPT FROM THE SEA. But, in aiming to attract the sophisticated movie-goer, who will easily see through the stylistic posturing, the film makers have virtually assured that their product will have not audience. Considering the movie's lack of quality, that's not a bad thing.
Copyright 1997 James Berardinelli
- James Berardinelli e-mail<EMAIL_ADDRESS>The website has moved!! The new address is: http://movie-reviews.colossus.net/
"The cinema is not an art which films life: the cinema is something between art and life. Unlike painting and literature, the cinema both gives to life and takes from it..."
- Jean-Luc Godard
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


{% extends "base.html" %} {% load static %} {% block title %}Dashboard | Bibtex Add{% endblock title %} {% block content %}
If you finished, please mark as completed.


| ↓/↑ |
Select next or previous item, current selection is cleared |
|
| Ctrl+↑/↓ |
Move focus to next or previous item only |
|
| Shift+↑/↓ |
Range select next or previous item, current selection is cleared |
|
| Ctrl+Shift+↑/↓ |
Range select next or previous item, adding to current selection |
|
| Space |
Select focused item, current selection is cleared |
|
| Ctrl+Space |
Toggle focused item, current selection is not cleared |
|
| Ctrl+A |
Select all items |
|


What is this?
Resemble.js analyses and compares images with HTML5 canvas and JavaScript.
Try it for yourself.
Compare two images?
Drop two images on the boxes to the left. The box below will show a generated 'diff' image, pink areas show mismatch. This example best works with two very similar but slightly different images. Try for yourself!
Don't have any images to compare?
Why?
Resemble.js can be used for any image analysis and comparison requirement you might have in the browser. However, it has been designed and built for use by the PhantomJS powered visual regression library PhantomCSS. PhantomCSS needs to be able to ignore antialiasing as this would cause differences between screenshots derived from different machines.
Resemble.js uses the HTML5 File API to parse image data, and canvas for rendering image diffs.
How can I use it?
Retrieve basic analysis on image.
var api = resemble(fileData).onComplete(function(data){ return data; /* { red: 100, green: 100, blue: 100, brightness: 100, alpha: 100, white: 100, black: 100 } */ });
Use resemble to compare two images.
resemble(file).compareTo(file2).onComplete(function(){ return data; /* { misMatchPercentage : 100, // % isSameDimensions: true, // or false getImageDataUrl: function(){} } */ });
Take a look at the JavaScript for this demo page from a better example


Deprecated: This plugin has been removed from the Jenkins Update Centre
The iON service no longer exists.
Archived versions of this plugin remain available for download.
Plugin Information |
|---|
No information for the plugin 'ion-deployer-plugin' is available. It may have been removed from distribution. |
Deploy your mule application on iON at the end of your build.
How it works
The ion-deployer plugin uses the iON REST API to deploy your application. It runs as a publisher at the end of the build, only if the build is successful. First found mule application will be deployed in case of a multi-module build.
You can define multiple iON accounts in the global configuration section.
Then in the job configuration for the application enable iON deployment by selecting Deploy to iON. You will have to select your account and provide the target domain.
History
Version 0.9 (Feb 20, 2012)
- First release.


It's nice to see that the filtering has detected the impostor. But Here is my greeting
was
definitely not supposed to be printed.
The problem is that msg, err := greet(name)
does declare a new variable msg
, and also
accidentally shadows the result parameter err
. This is tricky because using the short declaration
operator :=
allows mixing new and existing variables, and it works well on
a very similar code. It depends whether the scope
of the existing variable is exactly the same as the scope of the assignment, or not.


I am currently a fourth-year undergraduate student at UC Davis studying Materials Science and Engineering with a focus in Mechanical Engineering. I love to learn which is why I have a diversified work background in electrochemistry, chemical engineering, semiconductors, composites, superconductor synthesis, and mechanical engineering. As an engineer, I want to contribute towards creating a greener world through developing the use of renewable resources and clean energy. I also want to incorporate the functions of origami into materials science and engineering by encorporating the hobby I love into the career I love.
Under the supervision of Valentin Taufour in the UC Davis Physics Department, I am on a team of researchers that synthesizes and characterizes exotic properties of new materials. I grew this beautiful purple crystal through anodic electrodeposition and detailed process refinement in order to increase sample purity and improve superconductive response. This has given me the amazing opportunity to independently manage and develop my own scientific project. Learn more about the research team here!
As an multiscale fabrication science and technology R&D intern at Sandia National Laboratories in Albuquerque, NM, my main project was electropolishing the aluminum MagLIF (Magnetic Linear Inertial Fusion) targets, seen on the left, to be used in Sandia's Z-machine. Micro-burrs and defects were introduced in the parts due to poor machining techniques and would ultimately be detrimental to the project goal. To selectively remove the part defects, I used electropolishing to focus current densities onto the high-surface-area defects, effectively oxidizing the burrs into solution while minimizing bulk mass-loss. I optimized electrochemical parameters such as agitation, temperature, pulse times, and chemistry compositions to eliminate pitting and minimize surface roughness.
I love origami and its seemingly limitless applications in engineering. I came up with this design as a submission for a crowdsourced NASA competition looking for conceptual origami radiation shields for future Mars mission habitats. The entries were judged on their ability to pack efficiently, deploy easily, and their level of protection. The design must fit inside a fairing of given dimention, encapsulate a pod with as many layers of material as possible, and be easily deployable. I finished among the 75th percentile and with an even deeper passion for origami. Feel free to check out my actual submission and some of my other origami work.


BlogRoll plugins for Carew
BlogRoll plugin
Summary
This is my first carew plugin is a simple « Blog Roll » plugin.
This plugin let you create easily a list of link via the yaml config file of your carew application.
How to install it
A package is available on packagist in order to make it very simple for you to install.
All you have to do is to edit your composer.json
file to add this requirement:
"bacardi55/carew-plugin-blogroll": "1.*dev"
Then, php composer.php update
or php composer.php install
depending on your case.
How to use it
Edit the carew config.yml file to enable the extension:
engine:
[…]
extensions:
…
- Carew\Plugin\BlogRoll\BlogRollExtension
…
Then, in the same file, you just need to add the list of links like this:
blogRoll:
lien1: http://lien1.com
lien2: http://lien2.com
Last step, you need to put the following code in your twig file:
{% for blog in carew.blogRoll %}
{{ blog.name }} {% endfor %}
blogRoll
is a variable that you can access in any twig template as soon as the extension is enabled.
Source code
You can find the code on github here.
The package can be found here on packagist.


Everything you need to do is on this one page. Nothing is stored by Fluky on the server and all the processing is done by your browser using JavaScript code - this avoids any possible security risks.
Pro Tip #1: There are import and export functions available: save your mark model for future use.
Pro Tip #2: Click the section headings to collapse them and save screen real estate...
Create your mark model here by first specifying the number of questions in your test, and the total marks available (100%). When you increment or decrement the number of questions you will notice the grid in the "Mark Setup" changes to reflect your setup. The "Mark Setup" section contains the setup for the test on a question by question basis, pertinently, the marks that should be allocated to each choice. Negative and part marks are also allowed.
The final test mark is the sum of all of the choice marks, however, zero marks will be awarded if the number of choices made is greater than the maximum number of choices allowed for that question!
Pro Tip #1: It might be worth considering making each question allow 2 answers, to compensate for extreme scanner sensitivity.
Pro Tip #2: If you change the default choice marks before you increment the number of questions, the next question will have a different default for that question!
This feature is not fully implemented, yet. The final CSV will not include knowledge area mark breakdowns.
| Question | A | B | C | D | E | QuestionMark | Max.Choices | KnowledgeArea |
|---|---|---|---|---|---|---|---|---|
| {{q.num}} |
Upload the .dat file that you received from the card scanner here. The file will be processed immediately according to the Mark Model above. If you change the Mark Model, do the upload again to re-process.
Click "Download CSV" and you will be prompted where you would like to save the .csv file which contains the marks. Save the file and then proceed to use Fluky to view the associated statistics.
Pro Tip: On occasion, incompetent students don't fill out their student number correctly. Unfortunately, you will have to manually figure out these cases.
Here you can view the marks for an individual card (student) as well as overall statistics.
| Question | Average Mark | Maximum Marks |
|---|---|---|
| {{q.q}} | {{q.ave | number:2}} | {{q.max}} |
| Question | Mark | Choices Made |
|---|---|---|
| {{m.q}} | {{m.mark}} | {{m.choices}} |


In the scss folder, you will find 3 files:
my-vars.scss contains all variables you can overwrite (commented out)
compositions.scss is basically "your-style". It is an example of how to build your own style guide.
index.scss takes care of loading files in the correct order and the only file that needs to be compiled.
That's it. It's that simple!
"npm run dev"
Don't forget to head over to HTML5 Boilerplate and support their awesome work. (and acknowledge their LICENSE.txt in this package)
SIC! {{lorem.rows(3).loop(4)}}


Doctor Recommender
Enter your ailment:
Get doctor recommendation
Enter the name of the doctor you are looking for:
Find doctor by name


Node Object¶
The node is a data structure used in the DSM to store data and create the hierarchy of the DSM document. Nodes are created with the complex type_ definition during parsing of source document. It can be used in the parsing time expressions
Fields:
| Field Name | Type | Description |
|---|---|---|
| parent | Node | parent node. |
| data | Map<String,Object>, List<Object> | holds the value of the current node. |
parent¶
parent field holds parent of the current node. parent of the result node is null.
Example usages:
self: point to current node self.parent: point to parent of current node. self.parent.parent: point to parent of current node. self.parent==null: is current node result node.
data¶
The data field holds the value of the current node.
if type_ definition of `Parsing Element`_ is an object_, data is a Map that contains properties of the current `Parsing Element`_ definitions.
Example Usage:
self.data: data is map self.data.foo: foo property of current node self.parent.data.foo: foo property of parent node self.data.bar.foo: foo property of the bar object in current node
If the type_ definition of the current Parsing Element is an array:
and If the parsing element definition has fields, data of one is Array , data of other is Map , two node is created. parent node holds array, child node holds map.
self.data is a Map self.parent.data is Array.
Example Usage:
self.data: data is map self.data.foo: foo property of current node self.parent[0].data.foo: foo property of first element of current array self.parent[self.parent.size()-1].bar: last element of current array
and If there are no fields_ in the `Parsing Element`_ definition,a node which the data field is array is created.
self.data is Array
Example Usage:
self.data: data is array self.data[0]: first property of array self.parent.data.foo: foo property of parent node self.parent[self.parent.size()-1].bar: last element of current array


--- layout: default hero-image: url(../assets/images/stock-images/pie-staff.jpg) hero-message: Get Involved! ---
We're mechanical engineers, software engineers, electrical engineers, industrial engineers. We build, design, reiterate, and improve with industry-grade products, and we plan and coordinate events, building relations with sponsors and organizations.
We're UC Berkeley students who care about making a difference in the lives of underrepresented students through STEM education. We run scholarship funds, workshops, and we teach students professional and life skills that can stay with them.
Our capstone: an annual robotics competition for undeserving high school students in schools in the Bay Area. 10 years in the running. More than $30,000 per year in funding. Run completely by UC Berkeley students. Lots of robots.
Learn more!Mechanical, Electrical, Software
Game Design, Events, Schools
Mentorship, Workshops, Metrics
Business, Web Applications, Staff
Want to help out? Here at PiE, we don't have an application process. Rather, we firmly believe that any UC Berkeley student who is interested in our club has something to offer, whether community-wise, project-wise, or anything else that we can't think of ourselves! Simply fill out the forms or come check out worksession and we'll get you started!


Open development tools to see the example calls and results :)
You can access the lib through
window.datetimePeriods


{% extends 'extractor/base.html' %} {% load static %} {% block content %} {#
{{ msg }}
File uploaded at: {{ uploaded_file_url }}
Return to home


Dog Sitting: 100+ hours
Reference:
I made my own schedual and was responsable for making sure the dogs were let out on time
CIT Everwood Day Camp
I am a hard working and dedicated student, who enjoys coding and computors. I lead my Computer Science group with pride. I keep my team members on task
and I give them the creative freedom they need. I am a very good swimmer and know many types of code, photoshop,
and information on computer hardware.


A lesson related to this project may discuss:
-
Use Levitating LED to demonstrate the concept of induction
-
Explain applications of electromagnets and wireless power
-
Explain how to build a strong electromagnet
-
Hands on activity: build your own electromagnet
-
Prizes and questions


LOGO
LINK 1
LINK 2
LINK 3
LINK 4
LINK 5
Fluid jumbotron
A SLIDESHOW OF PHOTOS OR EVEN INDIVIDUAL PHOTOS COMES IN HERE


Seems your browser doesn't support Javascript! Websocket relies on Javascript being enabled. Please enable Javascript and reload this page!
Main
Connect
Disconnect


{% extends "global/Page.html" %} {% load otree static %} {% block title %} Place Holder Poker Page {% endblock %} {% block content %}
Player won hand? {{ winner }} Was it a tie? {{ tie }} Hand Type was: {{ hand_type }}


Griffin Group Global - Full Stack Developer Challenge My Code
Home
(current)
Contacts
(current)
Welcome to the Create Contacts Page
On this webpage, you can easily create the new contacts.
First name:
Last name:
Email ID:


Iraq Boosts Security on Syrian Border to Prevent Daesh Terrorists Infiltration - Reports
MOSCOW (Sputnik) - Iraqi border guards along the Iraqi-Syrian frontier have increased security measures to prevent Daesh* terrorists from finding their way into the country, INA reported.
According to the INA news agency, Iraq is setting up defence structures along the border in the provinces of Nineveh and Anbar.
On Friday, a regional representative of Iraqi Kurdistan, which occupies a part of northern Iraq, said that up to 20,000 Daesh fighters still remained in Iraq and Syria.
In early November, the US news outlet NBC said that militants from the Daesh terrorist group, following their defeat in Syria, were moving across the border into northern Iraq to rebuild their forces there.
The jihadists received a powerful blow last month when Daesh leader Abu Bakr al-Baghdadi died in Idlib during a US military operation. The terrorists were also targeted by Turkish forces during Operation Peace Spring in northern Syria, which made them flee the region.
Iraq announced the defeat of the organisation in late 2017, three years after it overran much of the country. By March 2019, Iraqi forces, backed by US-led coalition airstrikes, recaptured all the territories occupied by the terrorist group in Iraq.
*Daesh (also known as Islamic State/ISIS/ISIL/IS) is a terrorist group banned in Russia


A game would be incomplete without some kind of audio, be it background music or sound effects. Unity’s audio system is flexible and powerful. It can import most standard audio file formats and has sophisticated features for playing sounds in 3D space, optionally with effects like echo and filtering applied. Unity can also record audio from any available microphone on a user’s machine for use during gameplay or for storage and transmission.
In real life, sounds are emitted by objects and heard by listeners. The way a sound is perceived depends on a number of factors. A listener can tell roughly which direction a sound is coming from and may also get some sense of its distance from its loudness and quality. A fast-moving sound source (like a falling bomb or a passing police car) will change in pitch as it moves as a result of the Doppler Effect. Also, the surroundings will affect the way sound is reflected, so a voice inside a cave will have an echo but the same voice in the open air will not.
To simulate the effects of position, Unity requires sounds to originate from Audio Sources attached to objects. The sounds emitted are then picked up by an Audio Listener attached to another object, most often the main camera. Unity can then simulate the effects of a source’s distance and position from the listener object and play them to the user accordingly. The relative speed of the source and listener objects can also be used to simulate the Doppler Effect for added realism.
Unity can’t calculate echoes purely from scene geometry but you can simulate them by adding Audio Filters to objects. For example, you could apply the Echo filter to a sound that is supposed to be coming from inside a cave. In situations where objects can move in and out of a place with a strong echo, you can add a Reverb Zone to the scene. For example, your game might involve cars driving through a tunnel. If you place a reverb zone inside the tunnel then the cars’ engine sounds will start to echo as they enter and the echo will die down as they emerge from the other side.
The Unity Audio Mixer allows you to mix various audio sources, apply effects to them, and perform mastering.
The manual pages for Audio Source, Audio Listener, Audio Mixer, the audio effects and Reverb Zones give more information about the many options and parameters available for getting effects just right.
Unity can import audio files in AIFF, WAV, MP3 and Ogg formats in the same way as other assets, simply by dragging the files into the Project panel. Importing an audio file creates an Audio Clip which can then be dragged to an Audio Source or used from a script. The Audio Clip reference page has more details about the import options available for audio files.
For music, Unity also supports tracker modules, which use short audio samples as “instruments” that are then arranged to play tunes. Tracker modules can be imported from .xm, .mod, .it, and .s3m files but are otherwise used in much the same way as ordinary audio clips.
Unity can access the computer’s microphones from a script and create Audio Clips by direct recording. The Microphone class provides a straightforward API to find available microphones, query their capabilities and start and end a recording session. The script reference page for Microphone has further information and code samples for audio recording.


The QuantConnect Algorithm Lab allows you to write code in project files and then press the Build button to compile your algorithm. Build errors will be displayed in the console and highlighted with red lines.
You can add, rename, and delete files in your project in the Projects tab. To rename your project, click into the project, hover over the title, and click on the pencil to the right of it. You can create a virtual folder for your project by placing a slash ("/") into the name of your file. The bare minimum to run an algorithm is your initialization and data event methods.
public class BasicTemplateAlgorithm : QCAlgorithm { public override void Initialize() { // Setup algorithm requirements: cash, dates and securities. // Initialize is called once at the start of the algorithm. } public override void OnData(Slice data) { // Data requested is then piped into event handlers like this one. } }
class BasicTemplateAlgorithm(QCAlgorithm): def Initialize(self): '''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.''' pass def OnData(self, data): '''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here. data: Slice object keyed by symbol containing the stock data ''' pass