FabØ
21-Feb-19 01:50 PM
Hey guys need your opinion, we will put a vote on twitter a pull request
few people contributed to put this together thank you
regarding the issue we have had with the founders CC causing a small inflation of supply,
we have reached out to JL777 who is fixing this issue as we speak. We have had multiple opinions on what to do with the funds,
from keeping them in our reserve for future developments, to a complete coin burn of all additional coins.
There are currently ""31,742,881"" coins which have been minted from the founders CC out of a total circulating supply of around 130,000,000.
We would like to reach out to the community and find a solution that works with everyone, while furthering
the vision of Ø CryptoUnion. One of the ideas and feedback we have received is that we should make use of the
funds in a fair way that benefits everyone (Early investors, Komodo holders, OCU, New investors and Development)
We have taken into consideration the % of inflation, the current low price of OUR, the fundraiser investors, and the effects
that these extra tokens will have on the price action. We would like some more feedback on whether this would be an appropriate solution and would
like to hear back from you, whether here or in private DM.
— 45% airdrop to current OUR holders, to offset any losses if we were to not burn the coins, allowing the early investors to stake and grow their OUR;
— 15% airdrop to Komodo holders, to gain more interest in the project, to spread the supply out more evenly ensuring fair distribution without having 1 or 2 people holding most of the supply,
as well as a thank you for the platform which has made this whole project possible for us;
— 5% reserved for twitter contests and discord drops, to thank you all for being in this community and to have small giveaways and contests;
— 25% Auctioned off in 30 lots of 250,000 OUR for BTC, the BTC of which will be held in a publically viewable address, with the BTC funds dedicated solely for the purpose of
coin listings and advertisement in the future. This would be a better solution than the current model of asking for donations to list on bigger exchanges, as well as giving everyone a chance to get
some more OUR at cheaper rates. This allows us to receive BTC without having to sell our native token, or causing downward price pressure while solving the issue of raising BTC for exchange listings;
— 10% Founders to use for further development of the platform.
This small early inflation would also lower the entry point into our OCU investment and loaning platform, allowing more people to get a higher membership tier for the same amount of OUR held.
With the very low liquidity, we dont think this additional supply would have much of an impact on price, taking into account our marketcap is below 1,000,000 atm and very low trading activity
it is more of an interest/publicity problem, and the airdrop will definitely help with that
I think that, along with burning any additional funds on top of whatever is currently in that address, would be a good solution
We think that auctioning off "additional" supply minted for BTC for purpose of furthering listings only and allowing more investors in really makes it work out to be a very good thing if it goes ahead
@ComputerGenie 👴👴👴 would definitely value your opinion on that we want anyone to be happy


cosmos development
Home
(current)
About
Portfolio
Hire Me
I am currently accepting freelance work and am interested in hearing about your projects!
For a quote and free consultation, please click
here
to email me and I will respond promptly.


More people use to stay in touch with friends and family, anytime and anywhere.TX'ME is free2 and offers
simple, secure, reliable messaging and calling, available on phones all over the world.
Reach people instantly. You’ll see when your message is delivered to your friend’s phone, plus when they’ve
seen it. This way, you can be sure your messages are going through like they’re supposed to.


Income/Expenses
Balance
Expenses
Income
Assets/Liabilities
Postings
Options
Files
Reload Files
Open File...
Currency:
Daily
Weekly
Monthly
Quarterly
Yearly
From:
To:
Avg
Max
Min
Total
Graph
Text
Graph
Text
Date
Accounts
Payee
Amount
Type
Date
Accounts
Payee
Amount


Thank you for testing the VerseGuide Overlay!
This is an early debug build. Many planned feature are still missing.
You can minimize this window and launch Star Citizen. With any luck you will see the in-game overlay indicator in the top right corner.
Please contact us on Discord to provide feedback.
Version v


How I Wish Matt's Presentation Would Be
June 2, 2014
This post reflects my point of view on Wordpress as a product and its development. It's a subjective review of the presentation and does not represent MalesBanget.com ( or it might )
Last night, I attended the 3rd Wordpress Jakarta Meetup at Binus University, Jakarta. Starring the famous Matt Mullenweg himself, I put a lot of hopes for opening my perspective about Wordpress future. Unfortunately, I was sadly mistaken.<!-- more -->
The Opening
Matt at 3rd Jakarta Wordpress Meetup
Matt opened the event with the history of how Wordpress evolved. This is my first time, watching his appearance and I must say that he's very realistic yet visionary kind of person. But, I'm not here for that. I'm here for more, to hear the plan how Wordpress will conquer the web, for at least more than 22% sites in the whole world.
There were few things that Matt only introduced a little about JetPack and mobile enhancement. Most of them were answered during the Q&A sessions. There's none on the 1/4 width of screen, displaying the presentation, but it was hardly move. I encouraged to raise my hand, but not selected. So, here's what I would like to hear, Matt.
What I Would Like To Hear
In this era of REST API and web openness, Wordpress needs to separate the product into 3 parts:
Backend Administration ( CMS )
Frontend
REST API
I know the Codex has been there for a very long time, but as a developer, I don't want to be entangled with Wordpress guidelines to build a website. I'm pretty sure that the companies would more consider to hire a all around PHP developer instead of Wordpress developer. Therefore, a REST API would be pretty good.
Then comes JetPack, bundled with many kind of features, including the JSON API. At first, I thought it is a solution for me to build a website using JetPack's API. But, it lacks of features and doesn't come with optional framework for developer to build a custom API.
Second thing is JSON API should be resided on the website's own platform. But, as far as I could read ( plus used it for 3 days ), we should connect to your domain https://public-api.wordpress.com/ instead of our own domain. I do worry about the load and access time during the connection to your domain, as local connection is much more preferred. Even though that you are using SSL, but as a developer ( and I think you will understand it ), our own ego forces us to get the data from our own domain. Not to mention that it would a cross domain call for AJAX based web application.
Enough for JetPack.
Caching System
Then I want to talk about the web performance. For few past years, we rely on SuperCache, a fascinating caching system that's ironically not from Wordpress. Why?
Static is The New Dynamic
I really want to support Wordpress and would be very happy to see your development plan, but honestly, I think this is a very fundamental issue that you would need to cover. There are plenty of CMS that we could more rely on, Ghost and AnchorCMS are two of examples.
I know that this event was organised by WPJkt , a great thanks for them. But, not all of the attendees are students, some of them are developers and we are keen to know your plan so we could still use Wordpress as a strategic product partner and not only because you have quite large portion of market share.
So, Matt. Would you do a rerun for your presentation in Jakarta?
Update: This event was hosted by WPJkt, not Binus University. Thanks for Valent for the implicit hint.


Hello! I want to encourage readers to wallow in the warm bath of asses' milk that is the new Hooting Yard Annexe. So while I was eating cake this morning, I had a bright idea. I wish to illustrate my bright idea with a picture of a lightbulb, but before I do that, I had better tell you what the bright idea is. Then I can eat some more cake. Actually, I've changed my mind. If you want to find out what my bright idea was, you will have to visit the Annexe entry for today's date. Here is the lightbulb:
Yours in Christ, Fatima Gilliblat


This folder contains example files from a project that Mary Cardenas and Erik
Spjut worked on in the Summer and Fall of 1998. The intent of the project was
to provide solutions to problems in Felder and Rousseau, 2nd Edition, which presented
both solution techniques and software tutorials. The problem numbers correspond
to the numbers in F&R 2nd. Ed., but the problem statements are included in
the .pdf files, so a copy of F&R is not needed.


"x" "1" "YOURTEE,DM AND KIRK-YOURTEE,CL, THE MUTAGENICITY OF AFLATOXIN Q1 TOSALMONELLA TYPHIMURIUM TA 100 WITH OR WITHOUT RAT OR HUMAN LIVER MICROSOMALPREPARATIONS, RES. COMMUN. CHEM. PATHOL. PHARMACOL. 54(1): __ 101-113,1986"


Servitor is a wrapper of TcpListener. It buffers incoming requests so that another thread can read them when they'd ready.
More...
|
| static void | Send (string data, string host, int port) |
| | Sends the specified data to the port at address More...
|
| |
| static string | LineFromClient (TcpClient client) |
| | Turns a TcpClient into text More...
|
| |
|
| bool | Changed [get, set] |
| | A boolean set up to determine whether input has been given since the last time it has been collected. More...
|
| |
| BindingsTable< string, string > | IOTable [get, set] |
| | Gets or sets the IO table. The IO Table determines, given an input, what to send to the server. More...
|
| |
Servitor is a wrapper of TcpListener. It buffers incoming requests so that another thread can read them when they'd ready.
Definition at line 18 of file Servitor.cs.
| HumDrum.Operations.Servitor.Servitor |
( |
| ) |
|
|
inline |
Set up the servitor with the default settings.
Definition at line 67 of file Servitor.cs.
| HumDrum.Operations.Servitor.Servitor |
( |
IPAddress |
address, |
|
|
int |
port |
|
) |
| |
|
inline |
Create a new servitor given an IPAdress and a port.
- Parameters
-
| address | The IP address to listen to |
| port | The port to listen on |
Definition at line 82 of file Servitor.cs.
| HumDrum.Operations.Servitor.Servitor |
( |
IPAddress |
address, |
|
|
int |
port, |
|
|
BindingsTable< string, string > |
table |
|
) |
| |
|
inline |
Initializes a new instance of the HumDrum.Operations.Servitor class. This allows the creation of a Servitor instance with an IOTable
- Parameters
-
| address | The address to listen to |
| port | The port to listen to |
| table | The table of inputs and outputs |
Definition at line 97 of file Servitor.cs.
| async Task<IEnumerable<string> > HumDrum.Operations.Servitor.Collect |
( |
| ) |
|
|
inline |
Gets all the input that the servitor has received since the last time it got any.
- Returns
- The list of the new input
Definition at line 107 of file Servitor.cs.
| static string HumDrum.Operations.Servitor.LineFromClient |
( |
TcpClient |
client | ) |
|
|
inlinestatic |
Turns a TcpClient into text
- Returns
- The text encoded in the stream
- Parameters
-
Definition at line 192 of file Servitor.cs.
| static void HumDrum.Operations.Servitor.Send |
( |
string |
data, |
|
|
string |
host, |
|
|
int |
port |
|
) |
| |
|
inlinestatic |
Sends the specified data to the port at address
- Parameters
-
| data | The data to send as a string |
| address | The address to send the data to |
| port | The port to which the data should be sent |
Definition at line 178 of file Servitor.cs.
| void HumDrum.Operations.Servitor.Start |
( |
| ) |
|
|
inline |
| const int HumDrum.Operations.Servitor.DEFAULT_PORT = 4206 |
| bool HumDrum.Operations.Servitor.Changed |
|
getset |
A boolean set up to determine whether input has been given since the last time it has been collected.
Definition at line 45 of file Servitor.cs.
| BindingsTable<string, string> HumDrum.Operations.Servitor.IOTable |
|
getset |
Gets or sets the IO table. The IO Table determines, given an input, what to send to the server.
The IO table
Definition at line 57 of file Servitor.cs.
The documentation for this class was generated from the following file:


Please check your inbox for "{{user.emailTemporary}}". We have sent a confirmation message to this email address with further instructions. Resend.


Support the Show
This episode does not have a sponsor and this podcast is a labor of love. If
you want to support the show, the best way to do it is to purchase one of my
courses or suggest one to a friend.
-
Dive into Docker is a video course that takes you from not knowing what Docker is
to being able to confidently use Docker and Docker Compose for your own apps.
Long gone are the days of "but it works on my machine!".
-
Build a SAAS App with Flask is a video course where we build a real
world SAAS app that accepts payments, has a custom admin, includes high test
coverage and goes over how to implement and apply 50+ common web app features.
There's over 20+ hours of video.


In a previous post about Swift, I talked about how static types were increasingly seen as important in programming language design. “Static” concerns a lot of developers, especially those using languages like Ruby or JavaScript. Let’s forget about that word and just talk about types.
What do we mean by types?
Types are everywhere, they are all around us, even now in your very programs. You can see them when you look at your browser, or when you start up your editor.
Morpheus is correct, types are at the absolute core of every program we write, “static” or not.
Although types are a deep topic, there’s not much to them when you get right down to it. From Wikipedia:
a type…determines the possible values for [data]; the operations that can be done on [that data]; the meaning of the data; and the way values of that type can be stored.
Take this Ruby routine:
1 2 3 |
|
Although you can’t see it in the source directly, x
has a type, as does the return value of square
.
Clearly, x
is intended to be a number. So, the valid values for x
would be all numbers. Invalid values would be booleans, strings, and anything else that isn’t a number. x
also supports an operation to multiply it by another number.
What about this routine:
1 2 3 |
|
You may think that both numerator
and denominator
have the same type. They do not. While both are ostensibly numbers, 0 is not a valid value for denominator
, because there’s no such thing as dividing by zero. denominator
has a slightly different type than numerator
in that there is one additional valid value for numerator
that is not valid for denominator
(namely, zero).
You’ll notice that none of the types are being made explicit–they are only in the mind of the programmer.
The Mind of a Programmer
Just because the source code doesn’t explicitly annotate the type of each variable, parameter, or routine, doesn’t mean no types were used in the creation of the code. It also doesn’t mean that the programmer didn’t have a set of valid values and available operations in mind when writing it.
This “programmer intent” of what accepted values and operations are is the very essence of programming. Programs exist to transform data across a series of operations, resulting in new data. Just because the types involved aren’t explicit, doesn’t mean they aren’t there.
There are many ways to make types more explicit. Depending on the language, you can define new types to codify your assumptions about what data is valid.
Suppose we are modeling an item for purchase. An item has a price:
1 2 3 4 5 6 7 8 9 |
|
We could have a guess at the type of price
. With just a modicum of domain knowledge
we could guess it’s some sort of number.
Suppose that in the system where this code appears, a “business rule” is that prices cannot be negative. Further, since it is a price, and monetary systems rarely go beyond two decimal points, the valid values for price may have at most two decimal places1.
If items and their prices are important to our system, it could be difficult to remember these restrictions as you work on the code. It could also be difficult for newcomers to understand these rules. Finally, there’s the question of what the value represents? The number of cents? The whole dollar amount as an IEEE Float?
Because the type isn’t explicitly laid out anywhere, the system is harder to understand and modify than it needs to be (as well as more prone to errors).
Let’s make this type explicit by defining a new type called Price
.
1 2 3 4 5 6 7 8 9 10 11 12 |
|
Now, because we have an explicit type defining a price in our system, anyone can easily understand the rules and logic about prices. We’ve also made it extremely difficult to use incorrectly (this is Ruby, after all, so the only things that are impossible are strong guarantees).
By defining the Price
type explicitly, we can now constrain the values for prices, but what about operations?
Operations
When the type of price
was implicitly defined, and stored using a system-provided
type (like Fixnum
), we automatically had access to a ton of operations that are
well-defined on that system type.
Although we’re unlikely to need to take the natural log of a price, we’ll certainly need to at least add two prices together, and we’ve lost that ability by defining Price
is merely a holder of valid data. We’ll need to add the operations explicitly.
This has an interesting effect on our design process. Because we no longer get a bunch of operations “for free”, we have to actually think through the operations we’ll need to add to our type, based on our system requirements.
Addition is pretty straightforward:
1 2 3 4 5 |
|
But what about subtraction? We might subtract prices when doing an exchange, refund, or discount, but if a price cannot be negative, what happens when we subtract one price from a lower-valued price? What if we do a percentage discount? What would half off an item that costs $33.33 be? It’s certainly not $16.665, because that’s not a valid price.
Because we actually have to explicitly define the operations on a Price
, we’ve
uncovered edge cases in our application logic that would’ve otherwise gone
un-noticed by keeping the type of price
implicit. By using types we’ve forced
ourselves to think through some critical application logic.
We’ve now seen that types always exist in our programs, and we can see how defining them explicitly has benefits to the design of our code. But how do we tell other developers what the types of variables, parameters, and return values are supposed to be?
I Do Declare
Type declaration is how we communicate the expected type of a variable, parameter, or return value. For example, our Item
class defined accessor methods for price
:
1 2 3 4 5 6 7 8 9 |
|
It may seem that no types have been actually declared here. While it’s true that the Ruby runtime allows any value to be passed to (or returned from) any routine, the programmer has made a clear intent as to the types involved.
Given that our system has an explicitly-defined type called Price
, it’s highly
likely that the programmer is declaring that price
returns a Price
and price=
expects a Price
as its parameter (and that @price
is intended to hold an instance of Price
). Compare to this code:
1 2 3 4 5 6 7 8 9 |
|
Here, the programmer has declared that the parameter to price=
is a number of cents, not a Price
. Even though the language is providing no guarantees
about the types of these values at runtime, the programmer has declared their types.
Let’s take a breath at this point and think of some words I haven’t used: static, compiler, inference, generics, annotate. There’s a difference between defining/declaring types and having a system that checks your code with respect to the constraints those types provide.
But let’s not get ahead of ourselves.
We’ve seen how we can both define and declare types in our code, but what good is it? Why is this code:
1 2 3 4 5 6 7 |
|
better than this:
1 2 3 |
|
Two words: boundaries.
Bound by Types
Any moderately complex system is broken down into parts. This application architecture is what allows us to work on complex systems without having to have the entire system in our head at once.
To make these parts of our system comprehensible, we define boundaries. These boundaries take the form of expected inputs and outputs. When a routine can be written with the assumption of only certain sorts of data coming in, it’s easier to write, understand, and change.
Types allow us to explicitly define the boundaries between bits of our code. Types allow us to encode in our programs—rather than in documentation or oral history—what the expectations are. Types also encourage us to think about how our program will behave, because we have to think about the operations that should be available.
It’s not like we aren’t doing this already. We are. It’s just a question of how explicit we want it to be and how much help we want along the way.
¡Ayúdame!
A simple way to check that types are being used correctly is to simply add code that checks:
1 2 3 |
|
An advantage of this means of type-checking is that it’s explicit, clear, obvious, and can be used “as-needed” (e.g. for critical entry points where mistakes are likely to be made). The disadvantage is that you will not find out until runtime if the wrong data has been used.
To deal with that, we can use tests so we have some assurances before the application is actually deployed:
1 2 3 4 5 |
|
In a language like Ruby, where there’s no built-in way to check or enforce type declarations, you can run out of options quickly.
There have been attempts to add richer type-checking systems to Ruby. Rails’ validations is probably the most prolific:
1 2 3 |
|
Here, we’ve declared the valid values of price
, and we can invoke the type-checker
by calling valid?
on the item. We can even get a detailed explanation of type
violations by calling errors
on the object.
You’re read that right–Rails validations are a type system (and a verbose and cumbersome one at that).
Type systems like Rails’ validations approach the limit of what you can do without direct language support.
And, it can be frustrating at times to carefully design the types your system needs, each one capturing business rules in code (instead of imprecise documentation or bafflingly-complex tests), only to have type errors occur in your running application2.
If you like the idea of modeling your system as a series of valid values and accepted operations on those values, you’re gonna need a new language.
Language!
Some languages (often called “statically-typed languages”) provide a way to verify that your program is using defined types correctly. Most of those languages are only able to to do this by requiring that all values have a type declaration (or that the type of a value can be unambiguously deduced).
If your last experience with such a language is this:
1
|
|
then it’s no wonder you aren’t a fan of having your source code checked for type correctness. And, if your main experience in defining types is this:
1 2 3 4 5 6 7 8 9 10 11 |
|
then it’s no wonder you aren’t a fan of using types in the first place.
Let’s see what our Item
and Price
types look like in a modern language that supports type-checking, Scala:
1 2 3 4 5 6 7 8 9 10 11 |
|
That’s 8 lines of Scala to 19 in Ruby. And our Scala version will not even execute if we’ve misused it.
These “static types” may not tell us everything about our program, but we know that an Item
will never contain an invalid price, ever:
1
|
|
Hopefully, you’re starting to see that explicit type declarations, and programs written to enforce them (often called compilers) are tools you can use to make sure that your notion of how your system behaves has been correctly encoded in the source (as opposed to thinking of them as fussy gatekeepers you must satisfy).
In modern, statically-typed languages, you end up explicitly declaring types only when the type of something is ambiguous. Turns Out™ that with modern tools this isn’t nearly as often as you might think.
Of course, this might be more often than you’d like, but there’s a nice side-effect to being explicit about the types of values in your program: you start to think in types. You decompose problems as operations on types of data.
You stop worrying
about edge cases, sanity checking, and whether or not “0” represents true
or
false
, and start focusing on the real problems you are solving (this is not to say that all programs written in statically-typed languages are bug free, easy to understand, or well-designed. Just that such languages contain additional tools for you to use on your quest for bug free, easy-to-understad, well-designed code).
Thinking this way leads to a system with clearly defined boundaries that is easier to understand and easier to modify. And the good news is that there are a lot of tools available to help you check your assumptions and validate at least part of your model of the problem.
That’s powerful.
- Ironically, the standard numeric types in most programming languages actually can’t hold all the valid values for the price that we’ve laid out. Try adding up the cost of 10 $0.10 items in a Ruby or JavaScript console. ↩
- Yes Virginia, calling methods on
nil
is a type error. So is getting a negative value when you “should never” get one. So is that time when you were writing your controller test and passed in booleans only to realize thatparams
in an actual running Rails app will only ever have strings in it and your passing test ended up telling you jack shit about how your code would actually behave. You know the time I mean. ↩


Ozone Filter, AngularJS Demo
Created by Erin Gaschott and Reilly Grant as a 2015 Grinnell College Externship Project
Filters
{{filter.name}}
Select a {{filter.name}}
Filter
Summer Olympic Medals Won per Category
{{data.displayField(field)}}
{{occurance}}
{{data.occuranceValue(field,occurance)}}


Outp = run(Q,Inp,Range,...)
Q
[ char ] - Reporting equations (rpteq) object.
Inp
[ struct ] - Input database that will be used to evaluate the reporting equations.
Dates
[ numeric ] - Dates at which the reporting equations will be evaluated; Dates
does not need to be a continuous date range.
Outp
[ struct ] - Output database with reporting variables.'dbOverlay='
[ true
| false
| struct ] - If true
, the LHS output data will be combined with data from the input database (or a user-supplied database).
'fresh='
[ true
| false
] - If true
, only LHS variables will be included in the output database, Outp
; if false
the output database will also include all entries from the input database, Inp
.
Reporting equations are always evaluated non-simultaneously, i.e. equation by equation, for each period.
Note the differences in the three output databases, d1
, d2
, d3
, depending on the options 'dbOverlay='
and 'fresh='
.
>> q = rpteq({ ...
'a = c * a{-1}^0.8 * b{-1}^0.2;', ...
'b = sqrt(b{-1});', ...
})
q =
rpteq object
number of equations: [2]
comment: ''
user data: empty
export files: [0]
>> d = struct();
>> d.a = tseries();
>> d.b = tseries();
>> d.a(qq(2009,4)) = 0.76;
>> d.b(qq(2009,4)) = 0.88;
>> d.c = 10;
>> d
d =
a: [1x1 tseries]
b: [1x1 tseries]
c: 10
>> d1 = run(q,d,qq(2010,1):qq(2011,4))
d1 =
a: [8x1 tseries]
b: [8x1 tseries]
c: 10
>> d2 = run(q,d,qq(2010,1):qq(2011,4),'dbOverlay=',true)
d2 =
a: [9x1 tseries]
b: [9x1 tseries]
c: 10
>> d3 = run(q,d,qq(2010,1):qq(2011,4),'fresh=',true)
d3 =
a: [8x1 tseries]
b: [8x1 tseries]


Created and maintained by Piotr and Oskar.
It wouldn't exist without MooTools community.
License
All code belongs to the poster and no license is enforced.
We are not responsible or liable for any loss or damage of any kind during the usage of provided code.


The functions in this section perform a global reduce operation
(for example sum, maximum, and logical and) across
all members of a group.
The reduction operation can be either one of a predefined list of
operations, or a user-defined operation.
The global reduction functions come in several flavors: a reduce that
returns the result of the reduction
to one member of a group,
an all-reduce that
returns this result
to all members of a group,
and
two
scan (parallel prefix)
operations.
In addition, a reduce-scatter operation combines the
functionality of a reduce and of a scatter operation.
Up: Contents
Next: Reduce
Previous: All-to-All Scatter/Gather
Return to MPI-2.2 Standard Index
Return to MPI Forum Home Page
(Unofficial) MPI-2.2 of September 4, 2009
HTML Generated on September 10, 2009


Grouping
Cypher
Sampling
Graph Sampling
Input Parameters
Graph
Small
Medium
Big
Reset Graph
Sampling Type
Random Vertex Sampling
Random Edge Sampling
Random Vertex Edge Sampling
Random Vertex Neighborhood Sampling
Random Non Uniform Vertex Sampling
Random Limited Degree Vertex Sampling
Page Rank Sampling
Sampling Type
In
Out
Both
Sampling Type
Simple Version
Nonuniform Version
Nonuniform Hybrid Version
Sampling Type
In
Out
Both
Sampling Threshold
Vertex Sampling Threshold
Edge Sampling Threshold
Vertex Degree Threshold
Dampening Factor
Maximum Number of Iterations
Sample Vertices With Values Greater Than Threshold
Keep Vertices With Same Score


This is a design document about implementing support for huge pages in Ganeti. (Please note that Ganeti works with Transparent Huge Pages i.e. THP and any reference in this document to Huge Pages refers to explicit Huge Pages).
The Linux kernel allows using pages of larger size by setting aside a portion of the memory. Using larger page size may enhance the performance of applications that require a lot of memory by improving page hits. To use huge pages, memory has to be reserved beforehand. This portion of memory is subtracted from free memory and is considered as in use. Currently Ganeti cannot take proper advantage of huge pages. On a node, if huge pages are reserved and are available to fulfill the VM request, Ganeti fails to recognize huge pages and considers the memory reserved for huge pages as used memory. This leads to failure of launching VMs on a node where memory is available in the form of huge pages rather than normal pages.
The following components will be changed in order for Ganeti to take advantage of Huge Pages.
Currently, It is possible to set or modify huge pages mount point at cluster level via the hypervisor parameter mem_path as:
$ gnt-cluster init \
>--enabled-hypervisors=kvm -nic-parameters link=br100 \
> -H kvm:mem_path=/mount/point/for/hugepages
This hypervisor parameter is inherited by all the instances as default although it can be overriden at the instance level.
The following changes will be made to the inheritence behaviour.
The hypervisor parameter mem_path and all other hypervisor parameters will be made available at the node group level (in addition to the cluster level), so that users can set defaults for the node group:
$ gnt-group add/modify\
> -H hv:parameter=value
This changes the hypervisor inheritence level as:
cluster -> group -> OS -> instance
Furthermore, the hypervisor parameter mem_path will be changeable only at the cluster or node group level and users must not be able to override this at OS or instance level. The following command must produce an error message that mem_path may only be set at either the cluster or the node group level:
$ gnt-instance add -H kvm:mem_path=/mount/point/for/hugepages
Memory management of Ganeti will be improved by creating separate pools for memory used by the node itself, memory used by the hypervisor and the memory reserved for huge pages as: - mtotal/xen (Xen memory) - mfree/xen (Xen unused memory) - mtotal/hp (Memory reserved for Huge Pages) - mfree/hp (Memory available from unused huge pages) - mpgsize/hp (Size of a huge page)
mfree and mtotal will be changed to mean “the total and free memory for the default method in this cluster/nodegroup”. Note that the default method depends both on the default hypervisor and its parameters.
If huge pages are set as default for a cluster of node group, then iAllocator must consider the huge pages memory on the nodes, as a parameter when trying to find the best node for the VM. Note that the iallocator will also be changed to use the correct parameter depending on the cluster/group.
The cluster balancer (hbal) will be changed to use the default memory pool and recognize memory reserved for huge pages when trying to rebalance the cluster.


Setup is run during app install, and can be used for creating config files and other 'run once' tasks.


# If you have a twitter developer account/app you can copy/paste your access information in place of my Sys.getenv("") functions
appname <- Sys.getenv("appname")
key <- Sys.getenv("key")
secret <- Sys.getenv("secret")
access_token <- Sys.getenv("access_token")
access_secret <- Sys.getenv("access_secret")
twitter_token <- create_token(
app = appname,
consumer_key = key,
consumer_secret = secret,
access_token = access_token,
access_secret = access_secret)
timeline_rtweet <- get_timeline("taylorswift13", n = 200)
#> Warning: 215 - Bad Authentication data.
#> Warning: rate limit exceeded. mins until rate limit resets.
head(timeline_rtweet)
#> # A tibble: 0 x 0
Since everyone may not have twitter developer access we have provided an example dataframe that we have previously scraped (NOTE, please set your working director to rtweetclean/vignettes to load this dataframe)…
created_at = c("2021-03-06 16:03:31",
"2021-03-05 21:57:47",
'2021-03-05 05:50:50',
'2021-03-05 7:32:33')
text <- c("example tweet text 1 @user2 @user",
"#example #tweet 2 ",
"example tweet 3 https://t.co/G4ziCaPond",
"example tweet 4")
retweet_count <- c(43, 12, 24, 29)
favorite_count <- c(85, 41, 65, 54)
timeline_rtweet_toy <- data.frame(text, retweet_count, favorite_count, created_at)
head(timeline_rtweet_toy)
#> text retweet_count favorite_count
#> 1 example tweet text 1 @user2 @user 43 85
#> 2 #example #tweet 2 12 41
#> 3 example tweet 3 https://t.co/G4ziCaPond 24 65
#> 4 example tweet 4 29 54
#> created_at
#> 1 2021-03-06 16:03:31
#> 2 2021-03-05 21:57:47
#> 3 2021-03-05 05:50:50
#> 4 2021-03-05 7:32:33
The first of our functions, clean_df()
is used to modify the timeline dataframe provided by rtweet by adding new columns by extraction information from tweets that tweepy does not provide on its own. The user is able to choose which columns are generated. Options for generateable columns include…
text_only
: strips emojis, hashtags, and hyperlinks from the text
column
word_count
: counts the number of words contained in the text_only
column
emojis
: contains the extracted emojis from tweet text
column
proportion_of_avg_retweets
: a proportion value of how many retweets a tweet received compared to the average in the dataframe
proportion_of_avg_favorites
: a proportion value of how many favorites a tweet received compared to the average in the dataframe
Different columns can be specified to be added by specifying their arguments as TRUE
or FALSE
when calling the clean_df()
function. They are all set to TRUE
by default.
clean_df <- function(raw_tweets_df,
text_only = TRUE,
word_count = TRUE,
emojis = TRUE,
proportion_of_avg_retweets = TRUE,
proportion_of_avg_favorites = TRUE)
| x |
|---|
| text_only |
| word_count |
| emojis |
| prptn_rts_vs_avg |
| prptn_favorites_vs_avg |
We can see that new columns have been added to the dataframe. The contents of these columns can be seen below alongside the original text column provided by rtweet for comparison…
kable(head( subset(cleaned_timeline, select=c(text,text_only,word_count,emojis, prptn_rts_vs_avg, prptn_favorites_vs_avg)),5))
| text | text_only | word_count | emojis | prptn_rts_vs_avg | prptn_favorites_vs_avg |
|---|---|---|---|---|---|
| example tweet text 1 @user2 @user | example tweet text 1 | 4 | 1.5925926 | 1.3877551 | |
| #example #tweet 2 | 2 | 1 | 0.4444444 | 0.6693878 | |
| example tweet 3 https://t.co/G4ziCaPond | example tweet 3 | 3 | 0.8888889 | 1.0612245 | |
| example tweet 4 | example tweet 4 | 3 | 1.0740741 | 0.8816327 |
tweet_words
can be used with a dataframe that is returned by clean_df()
and returns a list of the most frequently used words based on the text_only
column generated by clean_df()
. The top_n
argument can be adjusted to return a specified number of the most frequently used words in the text_only
column.
tweet_words(clean_rtweet_dataframe, top_n = 5)
tweet_words_example <- tweet_words(cleaned_timeline, top_n=30)
kable(tweet_words_example)
| words | count |
|---|---|
| tweet | 3 |
| example | 3 |
| text | 1 |
| 4 | 1 |
| 3 | 1 |
| 2 | 1 |
| 1 | 1 |
Takes the dataframe output of clean_df()
as input. Takes the text_only
column of tweets and returns a dataframe summarizing the number of tweeted words associated with particular emotional sentiments based on the ‘crowd-sourced NRC Emotion Lexicon’ . By default all sentiments listed in the lexicon will be presented regardless of if they are included in the dataset or not. If you wish to only see the sentiments that are present in the dataset then set drop_sentiment
to FALSE.
sentiment_total(clean_rtweet_dataframe, drop_sentiment = FALSE)
sentiment_total_example <- sentiment_total(cleaned_timeline, drop_sentiment = TRUE)
sentiment_total_example
#> # A tibble: 0 x 3
#> # … with 3 variables: sentiment <chr>, word_count <dbl>, total_words <int>
engegement_by_hour()
is used to return a line plot generated via ggplot2 of the combined total of likes and retweets a user received depending on the hour of day their tweets were made at. It takes either a dataframe returned by clean_df()
OR an unedited dataframe returned by the rtweet
function get_timeline()
as input and builds a graph based on the created_at
column.
engagement_by_hour(clean_rtweet_dataframe)
engagement_by_hour(cleaned_timeline)


Most apps would probably have some long article of legal disclaimer written by a team of lawyers which would release them from any liability. However since I am not a lawyer and don’t plan on hiring one just to make this app, this will be very unprofessional. Some may ask why I am even writing a legal section within this app, and to them I ask why not? First off the news events and the pictures they include are NOT owned by myself and belong to their respective owners. The grades served to you are taken from home-access.cfisd.net via HTTPS post requests and are processed through my webserver. These requests use TLS to encrypt your password and are not physically stored except for on your own device. As for the app itself, the code is publically available on github.com.
It is SSHH.IO's policy to respect your privacy regarding any information we may collect while operating our app. Accordingly, we have developed this privacy policy in order for you to understand how we collect, use, communicate, disclose and otherwise make use of personal information. We have outlined our privacy policy below.
We are committed to conducting our organization in accordance with these principles in order to ensure that the confidentiality of personal information is protected and maintained. SSHH.IO may change this privacy policy from time to time at SSHH.IO's sole discretion.


SimpleBlobDetector Class for extracting blobs from an image.
The class implements a simple algorithm for extracting blobs from an
image:
- Convert the source image to binary images by applying thresholding
with several thresholds from
MinThreshold
(inclusive) to
MaxThreshold
(exclusive) with distance ThresholdStep
between
neighboring thresholds.
- Extract connected components from every binary image by
cv.findContours and calculate their centers.
- Group centers from several binary images by their coordinates. Close
centers form one group that corresponds to one blob, which is
controlled by the
MinDistBetweenBlobs
parameter.
- From the groups, estimate final centers of blobs and their radiuses
and return as locations and sizes of keypoints.
This class performs several filtrations of returned blobs. You should
set FilterBy*
to true/false to turn on/off corresponding filtration.
Available filtrations:
- By color. This filter compares the intensity of a binary image at
the center of a blob to
BlobColor
. If they differ, the blob is
filtered out. Use BlobColor = 0
to extract dark blobs and
BlobColor = 255
to extract light blobs.
- By area. Extracted blobs have an area between
MinArea
(inclusive)
and MaxArea
(exclusive).
- By circularity. Extracted blobs have circularity
(
(4*pi*area)/(perimeter*perimeter)
) between MinCircularity
(inclusive) and MaxCircularity
(exclusive).
- By ratio of the minimum inertia to maximum inertia. Extracted
blobs have this ratio between
MinInertiaRatio
(inclusive) and
MaxInertiaRatio
(exclusive).
- By convexity. Extracted blobs have convexity
(area / area of blob convex hull) between
MinConvexity
(inclusive)
and MaxConvexity
(exclusive).
Default values of parameters are tuned to extract dark circular blobs.
|
|
addlistener |
Add listener for event. |
|
|
clear |
Clears the algorithm state |
|
|
delete |
Destructor |
|
|
detect |
Detects keypoints in an image or image set. |
|
|
empty |
Checks if detector object is empty. |
|
|
eq |
== (EQ) Test handle equality. |
|
|
findobj |
Find objects matching specified conditions. |
|
|
findprop |
Find property of MATLAB handle object. |
|
|
ge |
>= (GE) Greater than or equal relation for handles. |
|
|
getDefaultName |
Returns the algorithm string identifier |
|
|
gt |
> (GT) Greater than relation for handles. |
| Sealed
|
isvalid |
Test handle validity. |
|
|
le |
<= (LE) Less than or equal relation for handles. |
|
|
load |
Loads algorithm from a file or a string |
|
|
lt |
< (LT) Less than relation for handles. |
|
|
ne |
~= (NE) Not equal relation for handles. |
|
|
notify |
Notify listeners of event. |
|
|
save |
Saves the algorithm parameters to a file |
|
|
typeid |
Name of the C++ type (RTTI) |


1. the_veterans_name
Text | The veteran's name is [First Name] [Last Name]. Patient's provider, [Assigned Clinician], was...
Add
2. Best_Time_to_call
If Condition | [Best Time to Call ] [was_answered] [AND] [ Phone Number ] [was_answered]
2.1. the_best_time_to_c
Text | The best time to contact the veteran is [Best Time to Call ]. The veteran can be contacted at [Ph]...
2.2. else_block_1
Else
2.2.1 phone_number_was
If Condition | [ Phone Number ] [was_answered]
<IP_ADDRESS> contact_info
Text | Contact information for this veteran is: [ Phone Number ]
2.2.2 else_block_2
Else
Add
Add
Add
Add
Add
Add
2.2.3 no_contact_2
Text | No contact information was given.
Add
Add New Block
Edit Audit-C | VistA Questions and Answers Template
Help
Welcome Last Name, First Name | Logout
* This wireframe provide the workflow, the structure, and the interaction between some specific pages and sections in the eScreening project and it's covered all the interaction between the application features and behaviours.
* Some of the interaction between pages may require using a specific rules and steps in order to demonstrate.
* This wireframe still in progress.
IMPORTANT NOTE - Click to Expand
U.S. Department of Veterans Affairs | eScreening Health Assessment (Ver 1.0)
4. presenting_concerns_1
If Condition | [Presenting Concerns] [response_is] [Physical Health Concerns]
4.1. you_can_get
Text | You can get more legal information by calling<PHONE_NUMBER>.
Add
Add
3. the_veteran_has_e
Text | The veteran has expressed the following needs: [delimit([Presenting Concerns], "* ", "\n", ....
Add
5. best_time_to_call_2
If Condition | [Best time to call] [was_answered]
5.1. the_veteran_report_2
Text | The veteran reports that the best time to call is:
Add
Add
5.2. best_time_to_call_3
If Condition | [Best time to call] [response_is] 1
Add
5.2.1 all_day_1
Text | all day
Add
5.2.2 best_time_to_cal_4
Else if Condition | [Best time to call] [response_is] 2
Add
5.2.3 in_am
Text | in am
Add
5.2.4 best_time_to_ca_5
Else if Condition | [Best time to call] [response_is] 3
Add
5.2.5 in_pm_5
Text | in pm
Add
5.2.6 best_time_to_ca_5
Else if Condition | [Best time to call] [response_is] 4
Add
5.2.7 late_night
Text | late night
Add
5.2.8 else_6
Else
Add
5.2.9 user_ente_1
Text | user entered: [otherText([Best time to call])
Add
Manage Block
+ Add Variable
Block Type
Block Name
AND
+
OR
AND
Select Variable
Variable
Display Name
Type
Insert
demo_firstname
First Name
Question
Select
assigned_clinician
Assigned Clinician
Custom
Select
-
PTSD Formula
Formula
Select
demo_va_concerns
Presenting Concerns
Question
Select
+ Add Variable
+ Add Variable
+
OR
AND
Select Variable
Variable
Type
Insert
demo_language
Measure
Select
demo_will
Measure Answer
Select
demo_will_info
Custom
Select
mst1_2
Formula
Select
Mst_consult
Formula
Select
+ Add Variable
+
OR
AND
Select Variable
Variable
Display Name
Type
Insert
demo_firstname
First Name
Question
Select
assigned_clinician
Assigned Clinician
Custom
Select
-
PTSD Formula
Formula
Select
demo_va_concerns
Presenting Concerns
Question
Select
dep_score_phq9
Formula
Select
dep1_interest
Question
Select
dep2_down
Question
Select
dep3_sleep
Question
Select
dep4_tired
Question
Select
dep5_appetite
Question
Select
1
2
3
4
6. has_resutl_1
If Condition | [has_result] [PTSD Formula]
Add
6.2 ptsd_formula_1
If Condition | [PTSD Formula] [is_greater_than_or_equal_to] 3
Add
6.2.1 positive_1
Text | positive
Add
6.2.2 else_7
Else
Add
6.3. score_2
Text | score=[PTSD Formula]
Add
6.4 else_8
Else
Add
6.4 not_enough_info
Not enough information was given by the veteran to calculate PTSD 4Q.
Add
6.2.3 Block
Text | negative
Add
6.1 a_ptsd_1
Text | A PTSD screening test (PTSD 4Q) was
Add


Wendy Fan
Data Scientist/Bioinformatics Scientist
SKILLS
- 3 yrs
- 2 yr
- 2 yr
- 6 yrs
- 3 yrs
- 1 yr
- 3 yrs
- 1 yrs
- 1 yrs
CAREER SUMMARY
A Bioinformatics Scientist & Data Scientist, skilled in Python and R, also familiar with SQL, MATLAB and JavaScript. I’ve got lots of experience from data cleaning to model building and prediction. Together with my biology background, I also have years of study in the next generation sequencing and single cell sequencing data analysis. I consider myself highly organized, always plan and follow my checklist to handle multitasks.
SHOWCASE
- A screenshot from my Tensorflow gesture detection model test result, I used transfer learning with model SSD MobileNet v2 320x320 which was trained on the COCO 2017 dataset.
- Video test sample of the gesture detection model. Four gestures including ThumbsUp, ThumbsDown, ThankYou, and LongLive, was trained, each class incude less than 10 training images labeled by myself. The overall result is good, and model can be improved with more images. The repository is https://github.com/fanwenxiaoyu/ObjectDetection
- Model selection visualization from my Machine Learning for Childhood Obesity project. On the left is the test result for overweight and obesity groups. On the right is for obesity group only. Each model is shown with different color. There shows 5 scores for each model, accu for accuracy, precision, recall, specificity, and f1 for F1 score. The repository is https://github.com/fanwenxiaoyu/ChildhoodObesity
- Dynamic change graph made with tableau, showing the story of time about me and my husband. It's a small gift to my husband for the Chinese Valentine’s Day.
EDUCATION
-
M.S in Data Science
City College of New York, New York
- Major Areas:ETL, Data cleaning, Database buildup, SQL, Data analysis, Machine learning and model building，Data visualization.
- Relevant Coursework:Applied Machine Learning, Big Data, Applied Statistics, Database System, Data Engineering, Computer Vision，Bioinformatics.
-
M.S in Biology Engineering
University of Chinese Academy of Sciences, Beijing
- Research Topic: High-throughput sequencing of soil microorganisms and their relationship with extreme climate change.
- Publication:
[1]Li L, Fan W, Kang X, et al. Responses of greenhouse gas fluxes to climate extremes in a semiarid grassland[J]. Atmospheric environment, 2016, 142: 32-42.
[2]Gao W, Reed S C, Munson S M, et al. Responses of soil extracellular enzyme activities and bacterial community composition to seasonal stages of drought in a semiarid grassland[J]. Geoderma, 2021, 401: 115327.
-
B.S in Bioengineering
Agriculture University of Hebei, Hebei, China
- Major Areas: Genetics, Molecular Biology, Cell Biology, Microbiology, Cytology, Biochemistry, Fermentation
WORK EXPERIENCE
-
Bioinformatics Scientist
Analytical Biosciences (focused on single-cell RNA-seq)
- Use Python to do quality control of single-cell RNA-seq data and functions. Ensure data reliability and function stability. I’ve helped build up the world’s largest single-cell RNA-seq database.
- Demonstrate our product (OmniBrowser and OmniAnalyzer) to clients, and collect their feedback. I’ve hold several seminars with clients from drug manufacturers to scientific institutes.
- Design new & upgrade product functions such as auto annotation, biomarker discovery, and user visualization interface. Analyze dozens of competitor’s product. I’ve helped our product to iterate twice and go to market.
-
Auditor&Customer Service
New York Service Center for Chinese Study fellows. Inc
- Review, process applications, and help the applicants.
- Coordinate with higher authority to implement policy. Detect inaccuracy and confirm the correct information. I’ve helped thousands of clients to achieve their goals.
-
Bioinformatics Engineer
Somur Beijing technology co. LTD (Health Care Providers and Services)
- Project R & D and technical support.
- Collect and Clean next-generation sequencing data. Build up an analysis pipeline from scratch.
- Build models base on published papers and our data to predict indexes for the clients’ health report. I’ve analyzed thousands of infants’ and adults’ RNA-seq data and Generated personal reports for clients.
- Publication:Liang B, Fan W, Han J G, et al. An implementation of infants' gut microbiome maturation analyses by 16s rRNA from stool samples in extraction solution of room temperature[C]//2017 IEEE International Conference on Bioinformatics and Biomedicine (BIBM). IEEE, 2017: 910-914.
PROJECTS
-
Machine Learning for Childhood Obesity
Utilize machine learning to discover the potential influencing drivers for childhood obesity from a questionnaire dataset.
- ETL, data exploration, clean data and deal with missing values with multiple imputation. Deal with unbalanced data.
- Use Classification estimators to build models then find the most influencing features.
- Use Clustering & Regression to target the possible cause of childhood obesity.
[Skills Developed]: Python, MICE, Sklearn, Seaborn, Matplotlab.
-
Big Data: Geo-Distribution of Drug Abuse Related Tweets
Compute the density of drug abuse related tweets within 100 million geo-tagged tweets in urban level within minutes.
- Spatially filter targeted tweets within census tracts.
- Sum the tweets based on geographical boundaries and normalize the results by their population.
[Skills Developed]: Spark, Python.
-
Build Up a School Website
A website was built including a server and a client interface for students, faculty and admin. This was a group project and I was responsible for the faculty page where faculty can login their accounts and manage their courses. This project was executed with React.
- Build up a faculty page.
- Implement functions for the faculty to add students to a course, add assignments, and give grades.
[Skills Developed]: SQL, HTML, JavaScript, React, CSS.
-
R: Sea Surface Temperature Modeling
Build a suitable model with R to estimate sea surface temperature with data collected from satellites radiometer instruments. Backward selection was used to simplify the original model, and attributes reduced from 10 to 2 without significant loss of performance.
- ETL, variable preparation and split.
- Backward selection.
- Find an acceptable simplified model.
[Skills Developed]: R, DAAG, leaps, testthat.
-
Computer Vision: Door Detection
Identify the door in a photo with computer vision.
- Edge detection.
- Hough transfer to remain and connect lines.
- Filter properties to find the door.
[Skills Developed]: MATLAB.
-
Microbiome Shift Analysis under Extreme Climate Change
16s rRNA sequencing and studding the microbiome variation under extreme drought, heatwave or precipitation frequency change.
- DNA extraction and next generation sequencing.
- Data processing to generate OTU table.
- Analysis the microbiome variation under different treatment.
[Skills Developed]: Linux, Qiime.
-
Gug Microbiome Analysis Pipeline Buildup & Explore its Relationship with Human Health
Set up the production pipeline of next generation sequencing data processing.
- Build up a pipeline for 16s rRNA sequencing data.
- Predict human health indexes based on published results.
- Analysis the microbiome variation under different treatment.
[Skills Developed]: Linux, Qiime, Perl.


WE DELIVER use Grubhub.com
or UberEats.com
2 LOCATIONS!!
New Haven: 216 Crown St<PHONE_NUMBER>)
NH Hours: Sun&Mon 11a.m.-8p.m., Tue&Wed 11a.m.-8p.m.,Thu 11a.m.-2p.m., Fri&Sat 11a.m.-3a.m.
Branford: 49 Leetes Island Rd<PHONE_NUMBER>)
Branford Hours: Sun 6a.m.-2p.m., Mon-Sat 6a.m.-7p.m.


--- layout: default title: About permalink: /about/ ---
Basic description of the app. What it does and how it can help.
Quick paragraph on why better courses are a good idea. Include links to our content to illustrate further points. On that note, we will have to write some content.
we started as a father and son team. Both of us have been passionate about sailing and racing for our whole lives.
Loser
Jackass


TITANIC A review by Joe Chamberlain
Starring Leonardo DiCaprio; Kate Winslet; Billy Zane & Kathy Bates
So the question is -- is this the greatest movie of all time? Well, it's certainly the most successful. Maybe not the best movie of all time in my books, although I would have to say it comes pretty darn close. That's quite an admission coming from me, since I've never seen a love story that I didn't hate or fall asleep before the 1 hour mark. Titanic is just that a love story, even with the multimillion dollar sets and special effects, it is just a movie about the love two young passengers have for one another. I will have to admit, as love stories go, this was a very compelling one. Certainly, the best one I've ever seen. Although I still can't figure out what all the excitement is about regarding Leonardo DiCaprio. I guess I would have to be a teenage girl to figure out that one, but I digress. I went to see titanic not for the love story (I planned on tolerating it) but for the special effects. Believe it or not I actually found my cold-hearted self actually enjoying the romance between Jack Dawson (Leonardo DiCaprio) and Rose DeWitt Bukater (Kate Winslet). While, as I've already said, I don't see what the fuss is over Leo, after seeing this film I couldn't imagine it being made with actors other than DiCaprio and Winslet in the lead roles. A fact that I think speaks volumes about their performances. There was truly no doubt, in my little mind at least, that by the end of the movie the characters of Jack and Rose were deeply in love. Heck, I actually even started to care about their romance. (I think I'm getting too soft.)
Anyway, as they say, time flies when your having fun, and since I went to see the special effects, that is what I wanted to see. Now to get off topic for just a second, I was one of those who asked the burning questions before the movie came out. Who in their right mind spends 200 million dollars to make a film? Better yet on a film that everybody knows the ending to?  A whole lot of people asked those same questions.  Why? Well, because critics are not filmmakers, and while we like to comment on films, and are relatively knowledgeable on the subject, for the most part we don't know as much as the people who make them. This is abundantly true with regard to Titanic's director James Cameron. The same man who many considered would be run out of Hollywood just a few short months before the film opened, is now being recognized as being among the greatest directors of all time. I really don't think that anyone can say enough about the job that this guy did.
This brings me back around to the reason I went to see this film -- the special effects. The movie opens with breathtaking shots of the real Titanic on the bottom of the Atlantic, shot specifically for this film by director James Cameron. Although that almost pales by comparison to the special effects used during the last half of the movie as the ship is sinking. The 200 million dollar price tag is certainly evident on the screen. Both in the long shots where we get to see the great ship break up, and in the interior shots that were done in giant flooded tanks. If, like me, you go to Titanic for the special effects, I promise you will not be disappointed by anything that appears on the screen.
A funny thing happened as I was watching the Titanic in its final minutes above the water. As much as I was in awe of the effects, and the complexity of the production, something else happened. An eerie feeling came over me. Unlike other disaster movies, this one really happened. All too often, when we think of the real Titanic sitting there on the bottom of the ocean, we forget something. Oh, we remember the tragedy of the situation and that hund reds of lives were lost, but most of us never stop to think what it must have like to be there on that ship as it was going down. James Cameron has captured those last moments, in a way that will make you think wonder why you never thought about it like that before.
As spectacular as the special effects were, they could not overshadow a simple love story and the tragedy associated with one of the worst disasters of all time.
One of the greatest films ever made. 10/10 - I would give it a higher rating if I had one.
Visit The Movie Guy http://members.tripod.com/~MovieGuy/
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


Learning plan
Intention:
Develop a career based on remote work, and focused on projects matching my values.
To achieve my career and study goals, I can rely in my problem solving skills, especially computational thinking. I am usually able to overcome obstacles thanks to my love of learning and my ability to think out of the bitten path. I am also self-organised and flexible and do well in teams. However, as I am an introvert, always being surrounded by people can be exhausting. Another limitation I can face is second-guessing myself when I'm not 100% sure of what I'm doing. I also tend to take critics personnally.
While I'm at EDA, I'd like to get better a receiving critics/feedback. I also want to be more confident, assertive when talking about my technical skills.
My plan for the foundations is to do as much as I can, as soon as I can, so if I encountered obstacles or if life gets in the way, I have a safety buffer For the bootcamp, I think my focus will be more to go with the flow and focus on the essentials so I don't get lost into details. I hope that the flipped classroom model will help foster positive team work habits and relationships between students and with the facilitator. I'm looking forward working collaboratively, supporting others when they need it and being supported when I need it.
When facing a technical difficulties, I'll first go through the EDA framework detailed during Sprint 1. I'm expecting to be able to solve a lot of problems using the rubber duck technique. If I can't overcome the obstacle by myself in a raisonable amount of time, I'll turn to my cohort and ultimately to the facilitators. When facing personal problems, I'll first turn to my familly and friends for support. Depending on the context, I might also ask for help at EDA, but whatever it is, I'll make sure to let my cohort and the facilitators know that something is going on and how it might impaired my work or the way I engage with them. I'm expecting the facilitation team to let me the freedom to make my own way through the curriculum while making sure I'm staying on tracks. I also expect them to be there if I ask for support.
During Bootcamp
My long term goal is to be able to work remotely so I have the freedom the live the life I want. This involves travels but more than being a digital nomad, I want to have time to grow a garden, work on DIY projects, continue studying, contribute to the community, ...
My ideal career path would see me working on projects matching my values or based on values I support. I would love to see my work support social enterprises, give back to the community, help create a more creative and fair world. And on my way, I may inadvertantly become a team leader.
It's a little bit difficult right now to picture what skills I will end up with at the end of the bootcamp. It's actually slightly scary to think about it. But one thing is sure, even if I don't quickly get my foot in the door of the IT industry, I want to get involved in projects, online or during hackathons so I can apply what I learned. I also want to bring people together to help me realise one of my project: a collaborative map of products and services in Aotearoa engaging with environemental and social challenges, community education, developing a locally based economy, offering seasonal, handcrafted and fair trade produces, ...
During bootcamp, my biggest strengths will be my love for problem-solving, my empathy and listening skills and my ability to think outside of the box. When starting Foundations, I was a bit worried that I might not enjoy problem-solving as much as I thought I would and that I would be really get to "think". But those 10 weeks showed me I was wrong. I enjoyed being challenged and having to focus and push my brain. I also surprised myself adopting habits and strategies and realising they were part of the "Think like a developer" part of the course.
One the other hand, I will have to be careful not to get lost into details and not to try tackling too many things at the same time or I could get discouraged and doubt myself, as I've experienced during Foundations when I tried to get ahead of the curriculum at all costs. I'm counting on the Bootcamp to provide me with feedback on where I'm really at and what I need to improve.
The biggest non-technical challenge I'm expecting to face is finding my place in the cohort. I usually take some time before I find my place in a group, and I'm wondering how it will work with bootcamp requiring us to get to work together from the start and to find our marks very quickly. As the curriculum worked for me so far, I am more curious to see how it will work out rather than worried and I trust that the EDA team will facilitate the process. This will be an opportunity for me to improve my ability to connect with people in a short amount of time. But once I once I'll reach my comfort zone, I'd like to work on developing some leadership skills.
Bootcamp will be an intense 9 weeks. I want to be focused and trust the "learn in time" motto so I won't be squished under the workload. I'm hoping that I'll be able to disconnect during lunch breack, but to stay on campus after class to work with the rest of the cohort. Self-checks and weekly Tech-ins will provide an opportunity to reflect and raise problems on time before they have a negative impact.


Spring Boot
Repo root
Commit
Spring Boot Web Thymeleaf Example
List of branches:
master
Folder is empty!
File is empty!


7.10. Analytic Querying¶
GeoMesa provides advanced query capabilities through GeoTools query hints. You can use these hints to control various aspects of query processing, or to trigger distributed analytic processing. See Setting Query Hints for details on setting query hints.
7.10.1. Feature Sampling¶
Instead of returning all features for a query, GeoMesa can use statistical sampling to return a certain percentage of results. This can be useful when rendering maps, or when there are too many features to be meaningful.
Features can either be sampled absolutely, or sampled by a certain attribute. For example, given a series of points in a track, you may wish to sample by the track identifier so that no tracks are completely sampled out.
The sampling value should be a float in the range (0, 1), which represents the fractional value of features that will be returned. Due to distributed processing, the actual count returned is not guaranteed to equal the requested percentage - however, there will never be less features than requested. For example, if you sample 5 features at 10%, you will get back anywhere from 1 to 5 features, depending on how your data is distributed in the cluster.
| Key | Type | GeoServer Conversion |
|---|---|---|
| QueryHints.SAMPLING | Float | any float |
| QueryHints.SAMPLE_BY | String - attribute name (optional) | any string |
import org.locationtech.geomesa.index.conf.QueryHints;
// returns 10% of features, threaded by 'track' attribute
query.getHints().put(QueryHints.SAMPLING(), new Float(0.1));
query.getHints().put(QueryHints.SAMPLE_BY(), "track");
import org.locationtech.geomesa.index.conf.QueryHints
// returns 10% of features, threaded by 'track' attribute
query.getHints.put(QueryHints.SAMPLING, 0.1f)
query.getHints().put(QueryHints.SAMPLE_BY, "track");
...&viewparams=SAMPLING:0.1
7.10.2. Density Query¶
To populate heatmaps or other pre-rendered maps, GeoMesa can use server-side aggregation to map features to pixels. This results in much less network traffic, and subsequently much faster queries.
The result from a density query is an encoded iterator of (x, y, count)
, where x
and y
refer to
the coordinates for the center of a pixel.
In GeoServer, you can use the WPS DensityProcess to create a heatmap from the query result.
See Heatmaps for more information.
| Key | Type | GeoServer Conversion |
|---|---|---|
| QueryHints.DENSITY_BBOX | ReferencedEnvelope |
use WPS |
| QueryHints.DENSITY_WEIGHT | String | use WPS |
| QueryHints.DENSITY_WIDTH | Integer | use WPS |
| QueryHints.DENSITY_HEIGHT | Integer | use WPS |
import org.geotools.data.Transaction
import org.geotools.geometry.jts.ReferencedEnvelope.ReferencedEnvelope
import org.geotools.referencing.CRS
import org.locationtech.geomesa.accumulo.iterators.KryoLazyDensityIterator
import org.locationtech.geomesa.index.conf.QueryHints
val bounds = new ReferencedEnvelope(-120.0, -110.0, 45.0, 55.0, CRS.decode("EPSG:4326"))
query.getHints.put(QueryHints.DENSITY_BBOX, bounds)
query.getHints.put(QueryHints.DENSITY_WIDTH, 500)
query.getHints.put(QueryHints.DENSITY_HEIGHT, 500)
val reader = dataStore.getFeatureReader(query, Transaction.AUTO_COMMIT)
val decode = KryoLazyDensityIterator.decodeResult(bounds, 500, 500)
while (reader.hasNext) {
val pts = decode(reader.next())
while (pts.hasNext) {
val (x, y, weight) = pts.next()
// do something with the cell
}
}
reader.close()


Statements of Principles¶
The API provides up-to-date machine-readable feed of data from all in-force Statements of Principle – legislative instruments currently critical to DVA’s administration of Compensation and Support – Outcome 1 in the Portfolio Budget Statements, comprising around $6 billion dollars of expenditure. There are 700 instruments, covering over 350 medical conditions and over 8500 SoP Factors (circumstances linking a medical condition to a veteran’s service).
The feed is derived automatically from the Federal Register of Legislative Instruments – the authoritative source of law maintained by the Office of Parliamentary Counsel.
Currently, MyService uses this feed to:
Enable veterans to select SoP factors directly, shortcutting time-consuming correspondence and shortening claim processing time. Typically MyService calls this function several hundred times each week.
Obtain an accurate and up-to-date list of medical conditions for which DVA provides treatment and compensation.


Board of Directors
The day to day operations of the PFHOA are run by an all-volunteer Board of Directors, along with help from many other committee volunteers. The Board establishes the annual dues assessment and is responsible for using the money assessed to maintain and improve HOA property and offer programs which are of value to Prairie Fields residents, thereby increasing the value of the neighborhood.
To view PFHOA BoD meeting notes and minutes, click here! Monthly statements are available upon request.
* Denotes term ends December 31, 2017
The Prairie Fields HOA is governed by a Board of Directors (BOD), per the PF HOA BYLAWS. The Board exists to represent and support all members of the homeowners association.
Each member of the Board is elected to a two year term, with an election held in the fall of each year for the vacancies of the following year.


Problem description
The problem is that poeple create shitty base HTML.
What is wrong...
Then they format it properly...
...with semantic HTML ?
... with javascript and CSS.


- Local authority reference: 0930/09139385080004
- Property: Moon under the water, 5 - 7a Temple Place, Brighton BN3 7JB
{{title}}
If you've told us about any changes, you should upload documents to support them. We can make a more accurate decision if you provide us with evidence such as photos and floor plans.
When uploading documents:
- only PDF and JPEG files can be accepted (JPEGs are image files commonly used by digital cameras and smartphones)
- only 10 files in total can be accepted
- files must be less than 10MB each and 50MB in total
How do I convert a file into a PDF?
Converting a file into PDF format is very simple. The method is similar with most types of word processors. First, open the document you want to convert, then:
- click “File”
- choose either “Export”, “Export as PDF” or “Save as” (depending on your software)
- select “Create PDF” or “PDF”
- click on either “Publish” or “Save”
For Mac users and older software:
- click “File”
- select “Print”
- either click “PDF”, or choose a printer labelled “PDF”
- click either “Save” or “OK”
You could also search for websites that will convert your document for free.
I want to send more than 10 files or my files are too large.
If you have more than 10 files, or they’re too large for us to accept, you can call us.
Telephone
03000 501501
Opening hours: 8:30am to 5:00pm Monday to Friday. Closed on bank holidays.
Back {% include "includes/get_help.html" %}


{% extends "pythonathon_v3/base.html" %} {% block title %} Welcome to Pythonathon! {% endblock %} {% block content %} {% if latest_solution_list %}
| {{ solution.user.username }} has solved problem "{{ solution.question.name }}" for {{ solution.net_score }} points! |
Nobody's solved any problems yet. Be the first!
{% endif %} {% endblock %}


Chapter 5 Upgrading to a new version
Users are encouraged to re-install or re-compile Rcpp
and RcppArmadillo
prior to upgrading to a new version of mrgsolve
. To upgrade mrgsolve
, simply follow the install step above.
www.metrumrg.com
Users are encouraged to re-install or re-compile Rcpp
and RcppArmadillo
prior to upgrading to a new version of mrgsolve
. To upgrade mrgsolve
, simply follow the install step above.


The Cymunk Module¶
These classes have cdefed functions that cannot be read by Sphinx. Read the source if you want to find out more about using them.
This module extends the base functionality of KivEnt by integrating it with the Chipmunk2d Physics engine. This will allow you to perform complex collision detection and real-time 2d physics calculations on large numbers of entities simultaneously.
Physics¶
-
class
kivent_cymunk.physics.
PhysicsComponent
¶ The PhysicsComponent mainly exposes the ability to retrieve cymunk objects. You will want to review the documentation for the various parts of cymunk (and Chipmunk2D’s documentation) to properly use this system.
- Attributes:
entity_id (unsigned int): The entity_id this component is currently associated with. Will be <unsigned int>-1 if the component is unattached.
body (Body): returns the cymunk.Body for your physics component. Only set this if you are handling the adding and removal of your physics body from the cymunk.Space yourself.
unit_vector (tuple): Returns the current unit_vector describing the heading of your physics body. Does not support setting only getting.
shapes (list): Returns a list of the shapes attached to the body. Be careful when setting to appropriately handle the shapes being added or removed from the body.
shape_type (str): The type of shape this components body was initialized with. Only set if you have been modifying your body manually and you know what you’re doing.
-
class
kivent_cymunk.physics.
CymunkPhysics
(**kwargs)¶ Processing Depends On:
PositionSystem2D
,RotateSystem2D
,CymunkPhysics
CymunkPhysics is a GameSystem that interacts with the Cymunk Port of the Chipmunk2d Physics Engine. Check the docs for Chipmunk2d to get an overview of how to work with Cymunk.
This GameSystem is dependent on the
PositionComponent2D
andRotateComponent2D
in addition to its own component. It will write out the position and rotation of the cymunk.Body associated with your entity every frame to these components.- Attributes:
space (ObjectProperty): The Cymunk Space the physics system is using
gravity (ListProperty): The (x, y) gravity vector for the space.
iterations (NumericProperty): Number of solving iterations for the Space
sleep_time_threshold (NumericProperty): How long a Body is inactive in order to be slept in the space
collision_slop (NumericProperty): Collision_slop for the Space; i.e. how much collisions can overlap.
damping (NumericProperty): Damping for the Space. This is sort of like a global kind of friction. All velocities will be reduced to
damping*initial_velocity
every update tick.
-
add_collision_handler
(self, int type_a, int type_b, begin_func=None, pre_solve_func=None, post_solve_func=None, separate_func=None)¶ - Args:
type_a (int): the collision_type for the first Shape in the collision
type_b (int): the collision_type for the second Shape in the collision
Kwargs:
begin_func (function): called (once) when collision between 2 shapes first begins
pre_solve_func (function): called before every solve of the physics space where a collision persists
post_solve_func (function): called after every solve of the physics space where a collision persists
separate_func (function): called (once) when collision between 2 shapes ends.
Function to add collision handlers for collisions between pairs of collision_type. Collision functions for begin_func and pre_solve_func should return True if you want the collision to be solved, and False if you want the collisions to be ignored
Functions should accept args: space, arbiter You can then retrieve the
entity_id
’s of the colliding shapes with:first_id = arbiter.shapes[0].body.data second_id = arbiter.shapes[1].body.data
-
clear_component
(self, unsigned int component_index)¶
-
create_component
(self, unsigned int entity_id, str zone_name, args)¶
-
init_component
(self, unsigned int component_index, unsigned int entity_id, str zone_name, dict args)¶ Args:
args (dict): dict containing the kwargs required in order to initialize a Cymunk Body with one or more Shape attached. Shape types supported are ‘box’, ‘circle’, ‘poly’, and ‘segment’.The args dict looks like:
args = { 'entity_id': id, 'main_shape': string_shape_name, 'velocity': (x, y), 'vel_limit': float, 'position': (x, y), 'angle': radians, 'angular_velocity': radians, 'ang_vel_limit': float, 'mass': float, 'col_shapes': [col_shape_dicts], 'moment': float }
moment (if not specified) will be computed from component shapes
The col_shape_dicts look like:
col_shape_dict = { 'shape_type': string_shape_name, 'elasticity': float, 'collision_type': int, 'shape_info': shape_specific_dict }
shape_info dicts looke like this, depending on their shape:
box = { 'width': float, 'height': float, 'mass': float } circle = { 'inner_radius': float, 'outer_radius': float, 'mass': float, 'offset': (float, float) } poly = { 'mass': float, 'vertices': list, 'offset': (float, float)} segment = { 'mass': float, 'a': (float, float), 'b': (float, float), 'radius': float (beveling radius for segment), } If you want a solid circle set inner_radius to 0.
-
init_physics
(self)¶ Internal function that handles initalizing the Cymunk Space
-
on_damping
(self, instance, value)¶ Event handler that sets the damping of space.
-
on_gravity
(self, instance, value)¶ Event handler that sets the gravity of space.
-
query_bb
(self, list box_to_query, ignore_groups=[])¶ - Args:
- box_to_query (list): should be a list of [x, y, x+w, y+h] where x, y is the bottom left hand corner of the box, and w, h is the width and height of the box.
- Kwargs:
- ignore_groups (list): list of collision_types to ignore during this query.
Queries collisions inside a box.
-
query_segment
(self, vect_start, vect_end)¶ - Args:
vect_start (tuple): (x1, y1) start point of segment.
vect_end (tuple): (x2, y2) end point of segment.
Queries collisions between (x1, y1) and (x2, y2)
-
register_collision_type
(self, str type_name)¶
-
remove_component
(self, unsigned int component_index)¶
-
update
(self, dt)¶ Handles update of the cymunk space and updates the component data for position and rotate components.
Interaction¶
-
class
kivent_cymunk.interaction.
CymunkTouchComponent
¶ The CymunkTouchComponent keeps track of a PivotJoint and a Body that has not been added to the cymunk Space in order to control physics objects actually added to the world. The PivotJoint is bound to the touch_body of this component and the Body of the touched Entity.
- Attributes:
entity_id (unsigned int): The entity_id this component is currently associated with. Will be <unsigned int>-1 if the component is unattached.
touch_body (Body): This is a rogue body (unattached to the space) that influences another Body through a cymunk.constraint interaction.
pivot (PivotJoint): The constraint that acts on this body and the one it is attached to.
max_force (float): Maximum force the joint can exert on the attached body.
error_bias (float): The rate at which the joint is corrected.
-
class
kivent_cymunk.interaction.
CymunkTouchSystem
¶ Processing Depends On: PositionSystem2D, CymunkTouchSystem
The CymunkTouchSystem provides a way to interact with the entities in a CymunkPhysics GameSystem, either through touches or mouse clicks. Touched entities will be ‘dragged’. This system will generate new entities when receiving an on_touch_down event that collides with an entity in the space of the CymunkPhysics GameSystem with system_id: physics_system.
The entities will be generated in zone zone_to_use so make sure to set this up appropriately. This zone should not need more than 100 entities unless you are planning on receiving very many simultaneous touches.
This system will be dependent on its own component and a PositionComponent2D (default system_id: ‘position’) for processing.
- Attributes:
physics_system (StringProperty): Name (system_id) of the physics system to use with this system. Defaults to ‘cymunk_physics’.
touch_radius (NumericProperty): Size of the touch query to see which entities we are touching. Defaults to 20.
max_force (NumericProperty): Maximum force the PivotJoint will be able to exert. Defaults to 2500000.
max_bias (NumericProperty): The rate at which the joints for touch entities will be corrected. Defaults to 10000.
ignore_groups (ListProperty): List of collision_type (int) to ignore when performing the collision query in on_touch_down. Defaults to [].
zone_to_use (StringProperty): Name of the zone to create entities in. Defaults to ‘touch’.
-
clear_component
(self, unsigned int component_index)¶ Clears the component at component_index. We must set the pointers in the C struct to empty and the references in the CymunkTouchComponent to None.
Args:
component_index (unsigned int): Component to remove.
-
init_component
(self, unsigned int component_index, unsigned int entity_id, str zone, dict args)¶ The entities for this system are typically generated by its on_touch_down event. However, if you do need to create a component the args dict looks like:
You will also definitely want to look over how this GameSystem manipulates its components in the on_touch_down, on_touch_move, and on_touch_up event handling.
Args:
component_index (unsigned int): Index of the component to be initialized.
entity_id (usigned int): Identity of the entity we will be adding this component to.
zone (str): Name of the zone this entities memory will use.
args (dict): Contains the arguments for creating the PivotJoint. Described below.
Args dict looks like:
args = { 'touch_pos': (float, float), #Tuple of the position this touch is occuring at 'touched_ent': (unsigned int), #The id of the entity that was touched. 'max_bias': float, #The error correction rate for this connection 'max_force': float, #The maximum amount of force this joint can generate. }
-
on_touch_down
(self, touch)¶ The touch down handling for the CymunkTouchSystem queries the CymunkPhysics GameSystem with system_id: physics_system to see if any touches occur withtin a square of x +- touch_radius, y +- touch_radius.
If we do collide with an entity, we will take the first one and bind a new rogue body (unattached from the physics Space) together with the touched entity’s physics Body by creating a PivotJoint. The new entity representing the PivotJoint will be created in zone: zone_to_use.
-
on_touch_move
(self, touch)¶ The touch move handling keeps track of the touch entity generated in on_touch_down, updating its position to the new position of the touch.
-
on_touch_up
(self, touch)¶ On touch up, if we have previously set the ud[‘ent_id’] in on_touch_down we will remove this entity from the GameWorld as the touch is now over.
-
remove_component
(self, unsigned int component_index)¶ Before we clear the component we perform some cleanup on the physics objects, removing the _pivot PivotJoint from our Space. We also remove our entity from the entity_components aggregator at this time.
Args:
component_index (unsigned int): Component to remove.
-
update
(self, float dt)¶


RGB Color Layers in p5.js!
A step by step on how to separate an image by the maximum color in it's pixels. The end result will be a function where you can pass either 'RED', 'GREEN', or 'BLUE', as parameters and the output will be either the red, the green or the blue layer of the image used.
Image Loading
Since we are manipulating an image, our first step is going to be using the loadImage() method to upload an image to your sketch and setting up that image as your canvas!
- Use function preload() to load the Image onto your sketch.
- Set the canvas dimentions to the width and height of your image.
- Previous step will make sure image is displayed at the center (since we are setting it up as the canvas itself)
ColorLayer( ) Function
Let's create out ColorLayer function. This function should take in a color name as a paramenter. Since this is where we are manipulating the image, we shoud copy and paste the out Basic code from draw into our function. Everything from loadPixels to updatePixels.
Maximum Color
Our color layers rely on the color with the highest value in that pixel, so lets create a new variable called maxi and the the max() method to determine which of the rgb values is the highest. Since we are analysing each pixel, lets create this variable inside our double for loop.
Color Options
Our color options are RED, GREEN, and BLUE, so we are going to use those as the valid paramenters for our function. Lets create 3 if statements:
If the color name is 'BLUE', we are going to keep all the pixels with max of blue and set all of the other ones to white.
The same steps are true for 'RED' and 'GREEN'
Function Call
Our function is ready to go! All we need to do is call it. Let's do that in setup. Remember to pass in a color name!


--- layout: page-no-sidebar hero-bg: front-hero hero-header: content-modules/front-hero-header.html hero-module: function-modules/consumer-portal.html above-content: content-modules/consumer-above-content.html banner-bottom: front-banner-bottom ---
Nulla squid disrupt put a bird on it, commodo copper mug gentrify leggings retro selvage slow-carb waistcoat. Unicorn succulents salvia, 90's cardigan flannel cred XOXO nulla. Forage bitters man braid meditation, authentic chia copper mug et keytar vegan enim. Pok pok id craft beer duis kombucha authentic.
 Mollit eiusmod normcore, pour-over chicharrones scenester gentrify banh mi taxidermy cronut chillwave 3 wolf moon. Godard meh brooklyn schlitz ethical.
This was a great REALTOR® event that celebrated our association's leadership in the community.
This was a great REALTOR® event that celebrated our association's leadership in the community.
This was a great REALTOR® event that celebrated our association's leadership in the community.


Please make a one-time or monthly donation to support rainforest conservation. You can make a one-time donation in the amount of your choice by clicking the Donate button below.
To make a donation in the amount of $10, $20, $30 or $50 per month for a year, please select one of these options in the menu below. Then, click the Subscribe button to confirm your monthly donation.
If you would like to make a donation via check, please may your check payable to Rainforest Partnership and mail to P.O. Box 49268, Austin, TX 78765
Did you know that deforestation contributes to around 17% of all the carbon dioxide in the atmosphere? That's more than double the emissions of all the world’s cars and trucks combined. We have already lost over one third of the world's rainforest. We're on a mission to ensure the remaining two thirds is allowed to thrive! Here's how you're helping Rainforest Partnership address this issue:
Our unique bottom-up approach is the sustainable solution to protecting the rainforest. We help communities create income in a way that doesn't involve selling the forest to developers.
The rainforest not only contains an estimated 50% of all terrestrial life on earth, it also provides clean air for the entire planet and food for hundreds of millions of people. Every acre counts!
Regardless of whether you live in New Guinea, New York, or New Delhi, we share the same atmosphere. Without a healthy rainforest acting as the lungs of the planet, none of us will breathe clean air. Get involved today!
Join us to create jobs in the rainforest, save acres of trees, and defer CO2 for a healthy and sustainable future.


Context: The emergence of blockchain technologyhas facilitated innovative solutions for various domains, such assupply chains, healthcare, and social networking. Decentralizedapplication development can be challenging for citizen devel-opers without having technical knowledge. Even for the moreexperienced smart contract developer, decentralized applications’complexity can significantly delay the development process.
Method: Model-Driven Development platforms shift the focusof software development activity from coding to modeling forsoftware development companies. Accordingly, in this study, weintroduce a model-driven development platform for generatingsmart contract-based decentralized applications according totheir business models. The proposed platform enables citizendevelopers to design, deploy and simulate the behavior of de-centralized applications on actual permissioned or permissionlessblockchain systems.
Results: We evaluate the feasibility, usefulness, and efficiency ofthe platform in generating decentralized applications. The resultsshow that the proposed platform. . . provides a reliable approach for creatingmodel-driven development platforms for distributed hyperledgertechnology.
Conclusion: The study’s theoretical contribution is the observa-tion that the framework


Cell Game
In this game you are a cell that will be faced with many decisions regarding your fate. Your goal is to make intelligent choices that will benefit your host body. These decisions can include when or how to progress through the cell cycle or, if necessary, when to undergo apoptosis.


Table Of Contents
Contributing to WTForms¶
WTForms is an open-source library and changing and evolving over time. To that end, we are supported by the contributions of many people in the python community.
How to Contribute¶
WTForms is now on GitHub, so all contributions should be either associated with a pull request or with a ticket & patch.
Contribution Guidelines¶
Code submitted should:
- Be formatted according to the PEP8 style guideline except that it does not need to confirm to the 79-column limit requirement of the guideline.
- Have tests
- Unless it’s a bugfix, it should pass existing tests.
- New classes or methods should mean new unit tests or extending existing tests.
- Bugfixes can probably do with a regression test too (a test that would fail without this fix)
- Use naming schemes consistent with WTForms conventions
- Work on all versions of Python that WTForms currently supports (and python3 without needing 2to3). Take advantage of Travis-CI for running tests on all supported Python versions.
Note on API compatibility¶
WTForms is a very small library, but yet it’s possible to break API compatibility pretty easily. We are okay with breaking API compatibility for compelling features or major changes that we feel are worthwhile inclusions to the WTForms core, but realize that any API compatiblity break will delay the inclusion of your ticket to the next major release.
Some examples of API compatibility breaks include:
- Adding new attributes or methods to the base Form class
- Modifying the number of required arguments of core methods like
process()
- Changing the default behavior of a field.
However, it is still possible to add new features to WTForms without breaking API compatibility. For example, if one were looking to add Babel locale support to DecimalField, it could be done so long as by default, DecimalField behaved the same as it did before. This could look something like:
- Add a keyword arg
use_locale
to the constructor - Make the keyword default to
False
so the behavior without this arg is identical to the previous bevhavior. - Add your functionality and make sure all existing DecimalField tests work unchanged (and of course add new tests for the new functionality).


I was really impressed with the Corona virus simulations which appeared in The Washington Post recently. So much so that it inspired me to learn JavaScript. So this is my first attempt at learning html, css, and JavaScript.
This implements a Susceptible-Infected-Recovered (SIR) model in a small finite population of agents moving about at random. All agents (apart from patient zero) starts off susceptible. An agent will get infected if they come into contact with an infected agent.
For fun and educational purposes only. Do not make any life decisions based upon this simulation. Code is available on my GitHub.