It is important to note, that Oracle not yet fully supports the automatic installation of Java 8.
In case that you are directed to
a Java download for Java 7, please ignore that version and download the Java 8 from the following Java page.
Official Oracle Java8 Download page
Please pay also attention that you select the correct version (64Bit or 32Bit). The bit version is not dependent from the Operating Version you are using but from the browser. If the browser you're using is 32-bit, then please install a 32-bit version of Java8.
Some browsers will show a dialog whether to download or to start a program. Chrome is one of those browsers, please follow the solution here.
If you are on Mac, even if the application is signed by an official certificate, security settings are blocking JavaWebStart.
Unfortunately, you have to adjust the security settings. Please read this article.


An implementation of Blackjack in Python 3.
For the very first programming assignment, we were required to write a Python program that allows a player to play a game of Blackjack against the computer. The program allowed a player to play as many games of Blackjack as they wish.
We were given a helper module that included the cards and a playing deck. Additionally, it also included functions to check whether the deck is empty, to reset the deck and to deal one card. We were also given a specific set of rules that our assignments would abide by.
With that, we set off to recreate Blackjack in Python.
As I had some prior experience with Python, I went a little overboard with my own assignment. The assignment specified a number of functions we had to implement, such as display_hand, get_hand_total and get_hit_choice. As this was the very first programming assignment, nothing complicated was used. I used lists, dictionaries, loops, subscripting, string concatenation, booleans and more to implement the required functions. After implementing the required functions, it was fairly simple to begin implementing the rules of Blackjack. At the end of the game, the user is prompted whether they would like to play again. If they don't statistics are shown that includes the number of games the user won or lost.


[gecode-users] Reporting memory usage
Gustavo Gutierrez
gutierrez.gustavo at uclouvain.be
Thu Oct 30 14:39:24 CET 2008
On Thu, Oct 30, 2008 at 12:32 PM, Filip Konvička <filip.konvicka at logis.cz>wrote:
> Hi Christian,
>
> actually this has been on my todo list for some time: I tend to use stl
> containers here and there in my branchings, so the nice thing here would
> be providing some allocators that allocate from space memory, which
> would enable us to use things like std::set, std::unordered_set etc.
> without hassle. Another nice thing is that I would no longer need to
> enforce calling destructors of members manually in "dispose()". I'll
> take a look at the space memory API to see whether it's possible.
>
I agree, it would be nice to have such thing in gecode. I have been using an
implementation of such allocator (attached to this mail). It would be nice
if we can discuss and improve it. I got this implementation from Stéphane
Zampelli.
Regards,
Gustavo
>
> Cheers,
> Filip
>
> > Hi,
> >
> >
> >
> > The only reason to allocate globally and not from a space is if the
> > allocated entities are shared among several spaces. That's the case for
> > complete set variables as they use BDDs that might indeed be shared
> > across spaces.
> >
> >
> >
> > Unless you share across spaces you should always allocate from a space,
> > it's much faster (an deallocation is automatic as soon as the space gets
> > deleted)! But in any case, make sure that you do not leak memory
> >
> >
> >
> > Cheers
> >
> > Christian
> >
> >
> >
> > --
> >
> > Christian Schulte, www.ict.kth.se/~cschulte/
> >
> >
> >
> > *From:* users-bounces at gecode.org
> > [mailto:users-bounces at gecode.org] *On
> > Behalf Of *Gustavo Gutierrez
> > *Sent:* Wednesday, October 29, 2008 9:19 AM
> > *To:* Christian Schulte
> > *Cc:* gecode at gecode.org
> > *Subject:* Re: [gecode-users] Reporting memory usage
> >
> >
> >
> >
> >
> > On Tue, Oct 28, 2008 at 6:19 PM, Christian Schulte
> > <cschulte at kth.se
> > <mailto:cschulte at kth.se>> wrote:
> >
> > Hi,
> >
> >
> >
> > Damn that's missing in Gecode. A space takes into account what external
> > memory is allocated by propagators and branchings but not by variables.
> >
> >
> >
> > It will also not be that straightforward (I would have to think a
> > little) as a space does not maintain a list of all variables (in
> > contrast to propagators and branchings).
> >
> >
> >
> > Is it very important? If yes, we could try to come up with something
> > and add it for 3.0.
> >
> > It would be nice and useful to have it but of course we can use some
> > workaround: what we can do for now is to use some bash scripting to
> > measure the memory allocated by an specific process, unfortunately this
> > is not so standard from one operating system to another.
> >
> >
> >
> >
> >
> >
> >
> > What do you do right now? Do you use the same memory management
> > support for variables that is also used by the complete set
> variables?
> >
> > If i remember correctly, cpltset variables use an external library in
> > the buddy folder and use a disposer to free the memory allocated by
> > additional data structures. We are doing that right now. We are trying
> > to use boost libraries for our implementation and fortunately those
> > libraries provide a way to parametrize the allocator. The other
> > possibility will be to use an allocator that allocates memory from the
> > gecode heap and *never* deallocate it (this is because gecode memory
> > manager takes care of that (am i right?). Can you recommend or comment
> > on the advantages of one approach over the other?
> >
> >
> >
> > Regards,
> >
> > Gustavo
> >
> >
> >
> >
> > ------------------------------------------------------------------------
> >
> > _______________________________________________
> > Gecode users mailing list
> > users at gecode.org
> > https://www.gecode.org/mailman/listinfo/gecode-users
>
>
> _______________________________________________
> Gecode users mailing list
> users at gecode.org
> https://www.gecode.org/mailman/listinfo/gecode-users
>
--
Gustavo Gutierrez
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.ps.uni-sb.de/pipermail/users/attachments/20081030/f1480ea4/attachment.htm>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: gecode_to_stl_allocator.hh
Type: application/octet-stream
Size: 2179 bytes
Desc: not available
URL: <http://www.ps.uni-sb.de/pipermail/users/attachments/20081030/f1480ea4/attachment.obj>
More information about the gecode-users
mailing list


---
layout: page
title: PLDI15-Artifact
---
Artifact
We provide two forms of our artifact which are as follows:
- Windows from here.
- Tar file for installation on linux machines from here.
{% include card.html
title="Paper #236"
url="https://www.sri.inf.ethz.ch/papers/pldi15.pdf"
output="horizontal"
description="Making Numerical Program Analysis Fast"
paper="https://www.sri.inf.ethz.ch/papers/pldi15.pdf"
%}
Instructions
- Virtual Machine
- Make sure you have 64-bit VirtualBox from Oracle.
- As some of the benchmarks take a lot of memory, make sure to give as much RAM as possible to the Virtual Machine (CRYPT benchmark in DPS Analyzer requires upto 12GB).
- The login credentials for the Virtual Machine are:
- Once the virtual Machine starts, go to the folder "pldi15-artifact" and open "Evaluation" file for instructions on how to compile the optoctagons library and run the analyzers.
- The virtual machine is the slower alternative as it does not support Intel's AVX Intrinsics. We measured upto 50% slowdown for optoctagons in virtual machine (running on the same machine). Some libraries used in Analyzers also run slowly in virtual machine so the speedup for end to end program analysis is also reduced.
- Tar File (Preferably for 64-bit Linux)
- Extract the tar file.
- Go to the folder "pldi15-artifact" and open "Evaluation" file for instructions on how to compile the optoctagons library and run the analyzers.


Note: The original size of the background image is 500x300 pixels, but using the background-size CSS property we are still able to show the complete image inside the smaller box.


Create contests for friends/colleagues/potential employees.
Enforce Champion-Challenger in Production.
Keep your data, create new evaluations and contest types.


Library Interface to GAP#
This module implements a fast C library interface to GAP.
To use it, you simply call libgap
(the parent of all
GapElement
instances) and use it to
convert Sage objects into GAP objects.
EXAMPLES:
sage: a = libgap(10)
sage: a
10
sage: type(a)
<class 'sage.libs.gap.element.GapElement_Integer'>
sage: a*a
100
sage: timeit('a*a') # random output
625 loops, best of 3: 898 ns per loop
Compared to the expect interface this is >1000 times faster:
sage: b = gap('10')
sage: timeit('b*b') # random output; long time
125 loops, best of 3: 2.05 ms per loop
If you want to evaluate GAP commands, use the Gap.eval()
method:
sage: libgap.eval('List([1..10], i->i^2)')
[ 1, 4, 9, 16, 25, 36, 49, 64, 81, 100 ]
not to be confused with the libgap
call, which converts Sage
objects to GAP objects, for example strings to strings:
sage: libgap('List([1..10], i->i^2)')
"List([1..10], i->i^2)"
sage: type(_)
<class 'sage.libs.gap.element.GapElement_String'>
You can usually use the sage()
method to convert the resulting GAP element back to its Sage
equivalent:
sage: a.sage()
10
sage: type(_)
<class 'sage.rings.integer.Integer'>
sage: libgap.eval('5/3 + 7*E(3)').sage()
7*zeta3 + 5/3
sage: gens_of_group = libgap.AlternatingGroup(4).GeneratorsOfGroup()
sage: generators = gens_of_group.sage()
sage: generators # a Sage list of Sage permutations!
[[2, 3, 1], [1, 3, 4, 2]]
sage: PermutationGroup(generators).cardinality() # computed in Sage
12
sage: libgap.AlternatingGroup(4).Size() # computed in GAP
12
We can also specify which group in Sage the permutations should consider themselves as elements of when converted to Sage:
sage: A4 = groups.permutation.Alternating(4)
sage: generators = gens_of_group.sage(parent=A4); generators
[(1,2,3), (2,3,4)]
sage: all(gen.parent() is A4 for gen in generators)
True
So far, the following GAP data types can be directly converted to the corresponding Sage datatype:
GAP booleans
true
/false
to Sage booleansTrue
/False
. The third GAP boolean valuefail
raises aValueError
.GAP integers to Sage integers.
GAP rational numbers to Sage rational numbers.
GAP cyclotomic numbers to Sage cyclotomic numbers.
GAP permutations to Sage permutations.
The GAP containers
List
andrec
are converted to Sage containerslist
anddict
. Furthermore, thesage()
method is applied recursively to the entries.
Special support is available for the GAP container classes. GAP lists can be used as follows:
sage: lst = libgap([1,5,7]); lst
[ 1, 5, 7 ]
sage: type(lst)
<class 'sage.libs.gap.element.GapElement_List'>
sage: len(lst)
3
sage: lst[0]
1
sage: [ x^2 for x in lst ]
[1, 25, 49]
sage: type(_[0])
<class 'sage.libs.gap.element.GapElement_Integer'>
Note that you can access the elements of GAP List
objects as you
would expect from Python (with indexing starting at 0), but the
elements are still of type
GapElement
. The other GAP container
type are records, which are similar to Python dictionaries. You can
construct them directly from Python dictionaries:
sage: libgap({'a':123, 'b':456})
rec( a := 123, b := 456 )
Or get them as results of computations:
sage: rec = libgap.eval('rec(a:=123, b:=456, Sym3:=SymmetricGroup(3))')
sage: rec['Sym3']
Sym( [ 1 .. 3 ] )
sage: dict(rec)
{'Sym3': Sym( [ 1 .. 3 ] ), 'a': 123, 'b': 456}
The output is a Sage dictionary whose keys are Sage strings and whose
Values are instances of GapElement()
. So,
for example, rec['a']
is not a Sage integer. To recursively
convert the entries into Sage objects, you should use the
sage()
method:
sage: rec.sage()
{'Sym3': NotImplementedError('cannot construct equivalent Sage object'...),
'a': 123,
'b': 456}
Now rec['a']
is a Sage integer. We have not implemented the
conversion of the GAP symmetric group to the Sage symmetric group yet,
so you end up with a NotImplementedError
exception object. The
exception is returned and not raised so that you can work with the
partial result.
While we don’t directly support matrices yet, you can convert them to
Gap List of Lists. These lists are then easily converted into Sage
using the recursive expansion of the
sage()
method:
sage: M = libgap.eval('BlockMatrix([[1,1,[[1, 2],[ 3, 4]]], [1,2,[[9,10],[11,12]]], [2,2,[[5, 6],[ 7, 8]]]],2,2)')
sage: M
<block matrix of dimensions (2*2)x(2*2)>
sage: M.List() # returns a GAP List of Lists
[ [ 1, 2, 9, 10 ], [ 3, 4, 11, 12 ], [ 0, 0, 5, 6 ], [ 0, 0, 7, 8 ] ]
sage: M.List().sage() # returns a Sage list of lists
[[1, 2, 9, 10], [3, 4, 11, 12], [0, 0, 5, 6], [0, 0, 7, 8]]
sage: matrix(ZZ, _)
[ 1 2 9 10]
[ 3 4 11 12]
[ 0 0 5 6]
[ 0 0 7 8]
Using the GAP C library from Cython#
Todo
Expand the following text
We are using the GAP API provided by the GAP project since GAP 4.10.
AUTHORS:
William Stein, Robert Miller (2009-06-23): first version
Volker Braun, Dmitrii Pasechnik, Ivan Andrus (2011-03-25, Sage Days 29): almost complete rewrite; first usable version.
Volker Braun (2012-08-28, GAP/Singular workshop): update to gap-4.5.5, make it ready for public consumption.
Dima Pasechnik (2018-09-18, GAP Days): started the port to native libgap API
- class sage.libs.gap.libgap.Gap#
Bases:
Parent
The libgap interpreter object.
Note
This object must be instantiated exactly once by the libgap. Always use the provided
libgap
instance, and never instantiateGap
manually.EXAMPLES:
sage: libgap.eval('SymmetricGroup(4)') Sym( [ 1 .. 4 ] )
- Element#
alias of
GapElement
- collect()#
Manually run the garbage collector
EXAMPLES:
sage: a = libgap(123) sage: del a sage: libgap.collect()
- count_GAP_objects()#
Return the number of GAP objects that are being tracked by GAP.
OUTPUT:
An integer
EXAMPLES:
sage: libgap.count_GAP_objects() # random output 5
- eval(gap_command)#
Evaluate a gap command and wrap the result.
INPUT:
gap_command
– a string containing a valid gap command without the trailing semicolon.
OUTPUT:
A
GapElement
.EXAMPLES:
sage: libgap.eval('0') 0 sage: libgap.eval('"string"') "string"
- function_factory(function_name)#
Return a GAP function wrapper
This is almost the same as calling
libgap.eval(function_name)
, but faster and makes it obvious in your code that you are wrapping a function.INPUT:
function_name
– string. The name of a GAP function.
OUTPUT:
A function wrapper
GapElement_Function
for the GAP function. Calling it from Sage is equivalent to calling the wrapped function from GAP.EXAMPLES:
sage: libgap.function_factory('Print') <Gap function "Print">
- get_global(variable)#
Get a GAP global variable
INPUT:
variable
– string. The variable name.
OUTPUT:
A
GapElement
wrapping the GAP output. AValueError
is raised if there is no such variable in GAP.EXAMPLES:
sage: libgap.set_global('FooBar', 1) sage: libgap.get_global('FooBar') 1 sage: libgap.unset_global('FooBar') sage: libgap.get_global('FooBar') NULL
- global_context(variable, value)#
Temporarily change a global variable
INPUT:
variable
– string. The variable name.value
– anything that defines a GAP object.
OUTPUT:
A context manager that sets/reverts the given global variable.
EXAMPLES:
sage: libgap.set_global('FooBar', 1) sage: with libgap.global_context('FooBar', 2): ....: print(libgap.get_global('FooBar')) 2 sage: libgap.get_global('FooBar') 1
- load_package(pkg)#
If loading fails, raise a RuntimeError exception.
- one()#
Return (integer) one in GAP.
EXAMPLES:
sage: libgap.one() 1 sage: parent(_) C library interface to GAP
- set_global(variable, value)#
Set a GAP global variable
INPUT:
variable
– string. The variable name.value
– anything that defines a GAP object.
EXAMPLES:
sage: libgap.set_global('FooBar', 1) sage: libgap.get_global('FooBar') 1 sage: libgap.unset_global('FooBar') sage: libgap.get_global('FooBar') NULL
- set_seed(seed=None)#
Reseed the standard GAP pseudo-random sources with the given seed.
Uses a random seed given by
current_randstate().ZZ_seed()
ifseed=None
. Otherwise the seed should be an integer.EXAMPLES:
sage: libgap.set_seed(0) 0 sage: [libgap.Random(1, 10) for i in range(5)] [2, 3, 3, 4, 2]
- show()#
Return statistics about the GAP owned object list
This includes the total memory allocated by GAP as returned by
libgap.eval('TotalMemoryAllocated()'), as well as garbage collection / object count statistics as returned by ``libgap.eval('GasmanStatistics')
, and finally the total number of GAP objects held by Sage asGapElement
instances.The value
livekb + deadkb
will roughly equal the total memory allocated for GAP objects (seelibgap.eval('TotalMemoryAllocated()')
).Note
Slight complication is that we want to do it without accessing libgap objects, so we don’t create new GapElements as a side effect.
EXAMPLES:
sage: a = libgap(123) sage: b = libgap(456) sage: c = libgap(789) sage: del b sage: libgap.collect() sage: libgap.show() # random output {'gasman_stats': {'full': {'cumulative': 110, 'deadbags': 321400, 'deadkb': 12967, 'freekb': 15492, 'livebags': 396645, 'livekb': 37730, 'time': 110, 'totalkb': 65536}, 'nfull': 1, 'npartial': 1}, 'nelements': 23123, 'total_alloc': 3234234}
- unset_global(variable)#
Remove a GAP global variable
INPUT:
variable
– string. The variable name.
EXAMPLES:
sage: libgap.set_global('FooBar', 1) sage: libgap.get_global('FooBar') 1 sage: libgap.unset_global('FooBar') sage: libgap.get_global('FooBar') NULL
- zero()#
Return (integer) zero in GAP.
OUTPUT:
A
GapElement
.EXAMPLES:
sage: libgap.zero() 0


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.apache.sling.adapter.SlingAdaptable org.apache.sling.jackrabbit.usermanager.resource.AuthorizableResource
public class AuthorizableResource
Resource implementation for Authorizable
| Field Summary |
|---|
| Fields inherited from interface org.apache.sling.api.resource.Resource |
|---|
RESOURCE_TYPE_NON_EXISTING |
| Constructor Summary | |
|---|---|
AuthorizableResource(org.apache.jackrabbit.api.security.user.Authorizable authorizable,
ResourceResolver resourceResolver,
java.lang.String path)
|
| Method Summary | ||
|---|---|---|
|
adaptTo(java.lang.Class<AdapterType> type)
Adapts the adaptable to another type. |
|
java.lang.String |
getPath()
This resource's path - for now that could be a JCR path. |
|
ResourceMetadata |
getResourceMetadata()
Returns the metadata of this resource. |
|
ResourceResolver |
getResourceResolver()
Returns the ResourceResolver from which this resource has been
retrieved. |
|
java.lang.String |
getResourceSuperType()
Returns the super type of the type of the resource or null
if the Resource.getResourceType() has no supertype. |
|
java.lang.String |
getResourceType()
The resource type is meant to point to rendering/processing scripts, editing dialogs, etc. |
|
java.lang.String |
toString()
|
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Constructor Detail |
|---|
public AuthorizableResource(org.apache.jackrabbit.api.security.user.Authorizable authorizable, ResourceResolver resourceResolver, java.lang.String path)
| Method Detail |
|---|
public java.lang.String getPath()
Resource
getPath
in interface Resource
public ResourceMetadata getResourceMetadata()
Resource
ResourceMetadata
object returned is implementation specific
except for the ResourceMetadata.RESOLUTION_PATH
property which is
required to be set to the part of the request URI used to resolve the
resource.
getResourceMetadata
in interface Resource
ResourceMetadata
public ResourceResolver getResourceResolver()
Resource
ResourceResolver
from which this resource has been
retrieved.
getResourceResolver
in interface Resource
public java.lang.String getResourceSuperType()
Resource
null
if the Resource.getResourceType()
has no supertype.
getResourceSuperType
in interface Resource
public java.lang.String getResourceType()
Resource
ResourceResolver
is free to set this to any suitable value such
as the primary node type of the JCR node from which the resource is
created.
If the resource instance represents a resource which is not actually
existing, this method returns the Resource.RESOURCE_TYPE_NON_EXISTING
.
getResourceType
in interface Resource
public <AdapterType> AdapterType adaptTo(java.lang.Class<AdapterType> type)
Adaptable
adaptTo
in interface Adaptable
adaptTo
in class org.apache.sling.adapter.SlingAdaptable
AdapterType
- The generic type to which this resource is adapted
totype
- The Class object of the target type, such as
Node.class
null
if the resource cannot
adapt to the requested typepublic java.lang.String toString()
toString
in class java.lang.Object
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Search for missing kayaker at Lake Cowichan suspended
by Cindy E. HarnettThe search for a missing man at Lake Cowichan has been suspended until further notice, according to Cowichan Search and Rescue.
Lake Cowichan RCMP were at the scene this morning where a missing man’s fishing kayak washed ashore near Little Shaw Creek. Seventy-year-old Colin Court has been missing since at least Friday.
At 10 a.m. Monday, all of the detachment’s officers were at the scene.
On Sunday, Cowichan Search and Rescue was scouring the shores and surface waters of Lake Cowichan after the kayak washed ashore.
Court, who celebrated his birthday on Thursday, told his family he was going flyfishing on Friday and that’s the last they heard from him, according to searchers.
RCMP have reported a motorist found a truck belonging to Court parked at the Little Shaw campground on Cowichan Lake, west of Youbou, on Saturday.
Rain plagued Saturday’s search, but crews returned to the search at daybreak on Sunday.
Lake Cowichan RCMP could not be reached for comment.


Hai Pham enjoys writing software that makes people happy!
I enjoys writing front-end code with these technologies
Thanks for visiting! Get in contact with HaiPham via Facebook @HaiPham


Anwar, Mahathir meet to discuss transition
PETALING JAYA: Malaysian Prime Minister Mahathir Mohamad and Parti Keadilan Rakyat president Anwar Ibrahim had a 30-minute meeting at the Perdana Leadership Foundation yesterday.
In a series of tweets, Mr Anwar said his and the Prime Minister's position on leadership transition has not changed from its agreed arrangement by Pakatan Harapan and as promised by Dr Mahathir.
"I requested the Prime Minister to issue statements relating to a few issues.
"I have informed him that the issue of the transition of power must be done peacefully and orderly, in a reasonable period and with mutual agreement," he said.
Mr Anwar added that their names should not be associated with any efforts to deviate from the agreement on the transition issue.
"We have also agreed to focus our attention on economic growth and towards the organisation of the Asia-Pacific Economic Cooperation (Apec) summit next year.
"The Prime Minister also took note of the various allegations towards certain Cabinet ministers who have been abusing their power or who have been raising political support through awarding projects," he said.
Dr Mahathir said that Mr Anwar understood the problems associated with the leadership transition.
"(Anwar) said that he understands the problems faced and that there should not be too much tension by people making all kinds of suggestions like the date of the transition," he told reporters at the sidelines of the Kuala Lumpur Summit.
Dr Mahathir had announced on Wednesday that a Cabinet reshuffle could happen before the Apec summit next year. - THE STAR


Yermah Options
Polling:
Check Yammer for new messages every
minute
2 minutes
5 minutes
Include own messages
Desktop Notifications:
Enable
Display notifications
for 5 seconds
for 10 seconds
for 20 seconds
until I dismiss them
Maximum number of notifications to show:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Apply
Reset


Matrix example application: Requires a local home server running at http://localhost:8008
No account? Register:
Got an account? Login:
Select a room
Member list:


|
Tubthumping
(Chumbawamba) |
|
We'll be singing
When we're winning We'll be singing I get knocked down But I get up again You're never going to keep me down Pissing the night away Pissing the night away He drinks a whisky drink He drinks a vodka drink He drinks a lager drink He drinks a cider drink He sings the songs that remind him Of the good times He sings the songs that remind him Of the better times: "Oh Danny Boy Danny Boy Danny Boy..." I get knocked down But I get up again You're never going to keep me down Pissing the night away Pissing the night away He drinks a whisky drink He drinks a vodka drink He drinks a lager drink He drinks a cider drink He sings the songs that remind him Of the good times He sings the songs that remind him Of the better times: "Don't cry for me Next door neighbour..." I get knocked down But I get up again You're never going to keep me down We'll be singing When we're winning We'll be singing |


{% extends "site_template.html" %} {% block headerName %} Ari Morcos {% endblock %} {% block title %} Neuroscience Research - Ari Morcos {% endblock %} {% block sectionName %} Neuroscience Research {% endblock %} {% block content %}
During my Ph.D., I studied how neuronal populations in cortex perform the computations relevant for complex behavior. In particular, I focused on evidence accumulation for decision-making. We make important decisions every day, and the vast majority of them require us to accumulate multiple discrete pieces of evidence on both short and long timescales to arrive at an accurate decision. For example, on a short timescale, when deciding which way to turn while driving, we might combine our position, streetsigns, information from maps, and landmarks to make a correct turn. The accumulation of evidence for decision-making is an essential component of our daily lives, and yet, the neuronal circuit mechanisms which perform the computations necessary for this complex task remain unknown.
To uncover the inner workings of these circuits, we used a recently developed behavioral paradigm to train mice to perform complex decision-making tasks requiring the accumulation of multiple, discrete pieces of evidence while using two-photon microscopy to simultaneously image the activity of hundreds of neurons in layers 2/3 of the Posterior Parietal Cortex (PPC). With these datasets in hand, we leveraged a variety of data analytics, ranging from the classic techniques of reverse correlation to recent breakthroughs in machine learning to uncover the inner workings of these circuits.
The neural dynamics underlying these tasks are incredibly complex and developing better methods to analyze these data is essential to our understanding. In particular, I focused on developing methods to analyze neuronal popualation dynamics on single trials. Using such analyses, we were able to identify multiple major features of the population activity, including a distributed code among heterogeneous individual neurons, history signals for past events lasting seconds, and structured trial-trial variability that was predictive of past and future activity patterns. Together, our results provide data that contradict the long-standing models of evidence accumulation and that propose a novel model of computation based on large-scale neuronal population dynamics.


This chapter introduces the Expression Language (also referred to as the EL), which provides an important mechanism for enabling the presentation layer (web pages) to communicate with the application logic (managed beans). The EL is used by several JavaEE technologies, such as JavaServer Faces technology, JavaServer Pages (JSP) technology, and Contexts and Dependency Injection for Java EE (CDI). The EL can also be used in stand-alone environments. This chapter only covers the use of the EL in Java EE containers.
The following topics are addressed here:
The EL allows page authors to use simple expressions to dynamically access data from JavaBeans components. For example, the test
attribute of the following conditional tag is supplied with an EL expression that compares 0 with the number of items in the session-scoped bean named cart
.
<c:if test="${sessionScope.cart.numberOfItems > 0}"> ... </c:if>
See Using the EL to Reference Managed Beans for more information on how to use the EL in JavaServer Faces applications.
To summarize, the EL provides a way to use simple expressions to perform the following tasks:
Dynamically read application data stored in JavaBeans components, various data structures, and implicit objects
Dynamically write data, such as user input into forms, to JavaBeans components
Invoke arbitrary static and public methods
Dynamically perform arithmetic, boolean, and string operations
Dynamically construct collection objects and perform operations on collections
In a JavaServer Faces page, an EL expression can be used either in static text or in the attribute of a custom tag or standard action.
Finally, the EL provides a pluggable API for resolving expressions so that custom resolvers that can handle expressions not already supported by the EL can be implemented.
The EL supports both immediate and deferred evaluation of expressions. Immediate evaluation means that the expression is evaluated and the result returned as soon as the page is first rendered. Deferred evaluation means that the technology using the expression language can use its own machinery to evaluate the expression sometime later during the page's lifecycle, whenever it is appropriate to do so.
Those expressions that are evaluated immediately use the ${}
syntax. Expressions whose evaluation is deferred use the #{}
syntax.
Because of its multiphase lifecycle, JavaServer Faces technology uses mostly deferred evaluation expressions. During the lifecycle, component events are handled, data is validated, and other tasks are performed in a particular order. Therefore, a JavaServer Faces implementation must defer evaluation of expressions until the appropriate point in the lifecycle.
Other technologies using the EL might have different reasons for using deferred expressions.
All expressions using the ${}
syntax are evaluated immediately. These expressions can appear as part of a template (static) text or as the value of a tag attribute that can accept runtime expressions.
The following example shows a tag whose value
attribute references an immediate evaluation expression that updates the quantity of books retrieved from the backing bean named catalog
:
<h:outputText value="${catalog.bookQuantity}" />
The JavaServer Faces implementation evaluates the expression ${catalog.bookQuantity}
, converts it, and passes the returned value to the tag handler. The value is updated on the page.
Deferred evaluation expressions take the form #{expr}
and can be evaluated at other phases of a page lifecycle as defined by whatever technology is using the expression. In the case of JavaServer Faces technology, its controller can evaluate the expression at different phases of the lifecycle, depending on how the expression is being used in the page.
The following example shows a JavaServer Faces h:inputText
tag, which represents a field component into which a user enters a value. The h:inputText
tag's value
attribute references a deferred evaluation expression that points to the name
property of the customer
bean:
<h:inputText id="name" value="#{customer.name}" />
For an initial request of the page containing this tag, the JavaServer Faces implementation evaluates the #{customer.name}
expression during the render-response phase of the lifecycle. During this phase, the expression merely accesses the value of name
from the customer
bean, as is done in immediate evaluation.
For a postback request, the JavaServer Faces implementation evaluates the expression at different phases of the lifecycle, during which the value is retrieved from the request, validated, and propagated to the customer
bean.
As shown in this example, deferred evaluation expressions can be
Value expressions that can be used to both read and write data
Method expressions
Value expressions (both immediate and deferred) and method expressions are explained in the next section.
The EL defines two kinds of expressions: value expressions and method expressions. Value expressions can be evaluated to yield a value, and method expressions are used to reference a method.
Value expressions can be further categorized into rvalue and lvalue expressions. An lvalue expression can specify a target, such as an object, a bean property, or elements of a collection, that can be assigned a value. An rvalue expression cannot specify such a target.
All expressions that are evaluated immediately use the ${}
delimiters, and although the expression can be an lvalue expression, no assignments will ever happen. Expressions whose evaluation can be deferred use the #{}
delimiters and can act as both rvalue and lvalue expressions; if the expression is an lvalue expression, it can be assigned a new value. Consider the following two value expressions:
${customer.name} #{customer.name}
The former uses immediate evaluation syntax, whereas the latter uses deferred evaluation syntax. The first expression accesses the name
property, gets its value, and passes the value to the tag handler. With the second expression, the tag handler can defer the expression evaluation to a later time in the page lifecycle if the technology using this tag allows.
In the case of JavaServer Faces technology, the latter tag's expression is evaluated immediately during an initial request for the page. During a postback request, this expression can be used to set the value of the name
property with user input.
A top-level identifier (such as customer
in the expression customer.name
) can refer to the following objects:
Lambda parameters
EL variables
Managed beans
Implicit objects
Classes of static fields and methods
To refer to these objects, you write an expression using a variable that is the name of the object. The following expression references a managed bean called customer
:
${customer}
You can use a custom EL resolver to alter the way variables are resolved. For instance, you can provide an EL resolver that intercepts objects with the name customer
, so that ${customer}
returns a value in the EL resolver instead. (JavaServer Faces technology uses an EL resolver to handle managed beans.)
An enum
constant is a special case of a static field, and you can reference such a constant directly. For example, consider this enum
class:
public enum Suit {hearts, spades, diamonds, clubs}
In the following expression, in which mySuit
is an instance of Suit
, you can compare suit.hearts
to the instance:
${mySuit == suit.hearts}
To refer to properties of a bean, static fields or methods of a class, or items of a collection, you use the .
or []
notation. The same syntax can be used for attributes of an implicit object, because attributes are placed in a map.
To reference the name
property of the customer
bean, use either the expression ${customer.name}
or the expression ${customer["name"]}
. Here, the part inside the brackets is a String
literal that is the name of the property to reference. The []
syntax is more general than the .
syntax, because the part inside the brackets can be any String
expression, not just literals.
You can use double or single quotes for the String
literal. You can also combine the []
and .
notations, as shown here:
${customer.address["street"]}
You can reference a static field or method using the syntax classname.field, as in the following example:
Boolean.FALSE
The classname is the name of the class without the package name. By default, all the java.lang
packages are imported. You can import other packages, classes, and static fields as needed.
If you are accessing an item in an array or list, you must use the []
notation and specify an index in the array or list. The index is an expression that can be converted to int
. The following example references the first of the customer orders, assuming that customer.orders
is a List
:
${customer.orders[1]}
If you are accessing an item in a Map
, you must specify the key for the Map
. If the key is a String
literal, the dot (.)
notation can be used. Assuming that customer.orders
is a Map
with a String
key, the following examples reference the item with the key "socks"
:
${customer.orders["socks"]} ${customer.orders.socks}
The EL defines the following literals:
Boolean: true
and false
Integer: As in Java
Floating-point: As in Java
String: With single and double quotes; "
is escaped as \"
, '
is escaped as \'
, and \
is escaped as \\
Null: null
Here are some examples:
${"literal"}
${true}
${57}
The EL offers support for parameterized method calls.
Both the .
and []
operators can be used for invoking method calls with parameters, as shown in the following expression syntax:
expr-a[
expr-b](
parameters)
expr-a.
identifier-b(
parameters)
In the first expression syntax, expr-a is evaluated to represent a bean object. The expression expr-b is evaluated and cast to a string that represents a method in the bean represented by expr-a. In the second expression syntax, expr-a is evaluated to represent a bean object, and identifier-b is a string that represents a method in the bean object. The parameters in parentheses are the arguments for the method invocation. Parameters can be zero or more values of expressions, separated by commas.
Parameters are supported for both value expressions and method expressions. In the following example, which is a modified tag from the guessnumber
application, a random number is provided as an argument rather than from user input to the method call:
<h:inputText value="#{userNumberBean.userNumber('5')}">
The preceding example uses a value expression.
Consider the following example of a JavaServer Faces component tag that uses a method expression:
<h:commandButton action="#{trader.buy}" value="buy"/>
The EL expression trader.buy
calls the trader
bean's buy
method. You can modify the tag to pass on a parameter. Here is the revised tag in which a parameter is passed:
<h:commandButton action="#{trader.buy('SOMESTOCK')}" value="buy"/>
In the preceding example, you are passing the string 'SOMESTOCK'
(a stock symbol) as a parameter to the buy
method.
Value expressions using the ${}
delimiters can be used
In static text
In any standard or custom tag attribute that can accept an expression
The value of an expression in static text is computed and inserted into the current output. Here is an example of an expression embedded in static text:
<some:tag> some text ${expr} some text </some:tag>
A tag attribute can be set in the following ways.
With a single expression construct:
<some:tag value="${expr}"/> <another:tag value="#{expr}"/>
These expressions are evaluated, and the result is converted to the attribute's expected type.
With one or more expressions separated or surrounded by text:
<some:tag value="some${expr}${expr}text${expr}"/> <another:tag value="some#{expr}#{expr}text#{expr}"/>
These kinds of expression, called composite expressions, are evaluated from left to right. Each expression embedded in the composite expression is converted to a String
and then concatenated with any intervening text. The resulting String
is then converted to the attribute's expected type.
With text only:
<some:tag value="sometext"/>
The attribute's String
value is converted to the attribute's expected type.
You can use the string concatenation operator += to create a single expression from what would otherwise be a composite expression. For example, you could change the composite expression
<some:tag value="sometext ${expr} moretext"/>
to
<some:tag value="${sometext += expr += moretext}"/>
All expressions used to set attribute values are evaluated in the context of an expected type. If the result of the expression evaluation does not match the expected type exactly, a type conversion will be performed. For example, the expression ${1.2E4}
provided as the value of an attribute of type float
will result in the following conversion:
Float.valueOf("1.2E4").floatValue()
Another feature of the EL is its support of deferred method expressions. A method expression is used to refer to a public method of a bean and has the same syntax as an lvalue expression.
In JavaServer Faces technology, a component tag represents a component on a page. The component tag uses method expressions to specify methods that can be invoked to perform some processing for the component. These methods are necessary for handling events that the components generate and for validating component data, as shown in this example:
<h:form> <h:inputText id="name" value="#{customer.name}" validator="#{customer.validateName}"/> <h:commandButton id="submit" action="#{customer.submit}" /> </h:form>
The h:inputText
tag displays as a field. The validator
attribute of this h:inputText
tag references a method, called validateName
, in the bean, called customer
.
Because a method can be invoked during different phases of the lifecycle, method expressions must always use the deferred evaluation syntax.
Like lvalue expressions, method expressions can use the .
and the []
operators. For example, #{object.method}
is equivalent to #{object["method"]}
. The literal inside the []
is converted to String
and is used to find the name of the method that matches it.
Method expressions can be used only in tag attributes and only in the following ways:
With a single expression construct, where bean refers to a JavaBeans component and method refers to a method of the JavaBeans component:
<some:tag value="#{bean.method}"/>
The expression is evaluated to a method expression, which is passed to the tag handler. The method represented by the method expression can then be invoked later.
With text only:
<some:tag value="sometext"/>
Method expressions support literals primarily to support action
attributes in JavaServer Faces technology. When the method referenced by this method expression is invoked, the method returns the String
literal, which is then converted to the expected return type, as defined in the tag's tag library descriptor.
A lambda expression is a value expression with parameters. The syntax is similar to that of the lambda expression in the Java programming language, except that in the EL, the body of the lambda expression is an EL expression.
For basic information on lambda expressions, see http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html
.
|
Note: Lambda expressions are part of Java SE 8, but you can use them in EL expressions with Java SE 7, the Java version associated with the Java EE 7 platform. |
A lambda expression uses the arrow token (->)
operator. The identifiers to the left of the operator are called lambda parameters. The body, to the right of the operator, must be an EL expression. The lambda parameters are enclosed in parentheses; the parentheses can be omitted if there is only one parameter. Here are some examples:
x -> x+1 (x, y) -> x + y () -> 64
A lambda expression behaves like a function. It can be invoked immediately. For example, the following invocation evaluates to 7:
((x, y) -> x + y)(3, 4)
You can use a lambda expression in conjunction with the assignment and semicolon operators. For example, the following code assigns the previous lambda expression to a variable and then invokes it. The result is again 7:
v = (x, y) -> x + y; v(3, 4)
A lambda expression can also be passed as an argument to a method and be invoked in the method. It can also be nested in another lambda expression.
The EL supports operations on collection objects: sets, lists, and maps. It allows the dynamic creation of collection objects, which can then be operated on using streams and pipelines.
|
Note: Like lambda expressions, operations on collection objects are part of Java SE 8, but you can use them in EL expressions with Java SE 7, the Java version associated with the Java EE 7 platform. |
For example, you can construct a set as follows:
{1,2,3}
You can construct a list as follows; a list can contain various types of items:
[1,2,3] [1, "two", [three,four]]
You can construct a map by using a colon to define the entries, as follows:
{"one":1, "two":2, "three":3}
You operate on collection objects using method calls to the stream of elements derived from the collection. Some operations return another stream, which allows additional operations. Therefore, you can chain these operations together in a pipeline.
A stream pipeline consists of the following:
A source (the Stream
object)
Any number of intermediate operations that return a stream (for example, filter
and map
)
A terminal operation that does not return a stream (for example, toList()
)
The stream
method obtains a Stream
from a java.util.Collection
or a Java array. The stream operations do not modify the original collection object.
For example, you might generate a list of titles of history books as follows:
books.stream().filter(b->b.category == 'history') .map(b->b.title) .toList()
The following simpler example returns a sorted version of the original list:
[1,3,5,2].stream().sorted().toList()
Streams and stream operations are documented in the Java SE 8 API documentation, available at http://docs.oracle.com/javase/8/docs/api/
. The following subset of operations is supported by the EL:
allMatch
anyMatch
average
count
distinct
filter
findFirst
flatMap
forEach
iterator
limit
map
max
min
noneMatch
peek
reduce
sorted
substream
sum
toArray
toList
See the EL specification at http://www.jcp.org/en/jsr/detail?id=341
for details on these operations.
In addition to the .
and []
operators discussed in Value and Method Expressions, the EL provides the following operators, which can be used in rvalue expressions only.
Arithmetic: +
, -
(binary), *
, /
and div
, %
and mod
, -
(unary).
String concatenation: +=
.
Logical: and
, &&
, or
, ||
, not
, !
.
Relational: ==
, eq
, !=
, ne
, <
, lt
, >
, gt
, <=
, ge
, >=
, le
. Comparisons can be made against other values or against Boolean, string, integer, or floating-point literals.
Empty: The empty
operator is a prefix operation that can be used to determine whether a value is null
or empty.
Conditional: A ? B : C
. Evaluate B
or C
, depending on the result of the evaluation of A
.
Lambda expression: ->
, the arrow token.
Assignment: =
.
Semicolon: ;
.
The precedence of operators, highest to lowest, left to right, is as follows:
[] .
()
(used to change the precedence of operators)
-
(unary) not ! empty
* / div % mod
+ -
(binary)
+=
<> <= >= lt gt le ge
== != eq ne
&& and
|| or
? :
->
=
;
Table 9-1 contains example EL expressions and the result of evaluating them.
Table 9-1 Example Expressions
| EL Expression | Result |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
[1,3,5,2].stream().sorted().toList() |
|
|
|
|
|
|
The context path |
|
|
The value of the |
|
|
The value of the request parameter named |
|
|
The host |
|
|
The value of the entry named |
${requestScope['javax.servlet.forward.servlet_path']} |
The value of the request-scoped attribute named |
|
|
Gets the value of the property |
|
|
The return value of the method |


{% block full_title %}{% block title %}SET THE TITLE{% endblock %} — {{ mission.title }} on Spacelog{% endblock %}
{% block extra_head %}{% endblock %}
{% if mission %}
{% comment %}
foaf:depiction and og:image are being repeated as separate properties because the Open Graph Protocol
is misusing RDFa slightly: in RDFa, the content attribute is used to represent literals (strings basically).
if you want to use a URI reference as the object, RDFa says you should use the href attribute.
one could combine all these together into one uber-element that has property, rel, content and href
but authors might not understand this in the same way.
see https://github.com/tommorris/Spacelog/commit/2850e1c71b94a92834cd27022c3dcee792e6787d
{% endcomment %}
{% endif %}
{% block masthead %}
{% include "_base/masthead.html" %}
{% endblock %}
{% block crest %}{% endblock %}


Due to the large sizes of these networks, we have turned off D3js by default
to load the page smoothly. Below, you can toggle it on or off. If you turn
it on, please be patient. Also, stick to the 'mention' and 'information'
networks, they are a bit more manageable in size than the 'hashtag' graph
and make sure to turn this one 'off' when you turn another one 'on'.
Only static images of the 'mention' and 'info' graph are included
since the 'hashtag' graph was to large to display.


You are now ready to join the game. Please wait for the other players to complete the tutorial steps.
When the game begins a "Ready" button will appear.


BotCore is a framework for writing and managing multiple Facebook Messenger bots through a common layer. It supports interfacing with facebook-chat-api and fbchat.
Check out the docs, or dive right in with examples!
npm install --save messenger-botcore
Generated using TypeDoc


Van Wong
About
|
Portfolio
|
Contact
Portfolio
Hangman
Cool App2
Neat Tool
Fancy API tool
Search Nei Restaurant


Bootstrap side by side div test
ONE with some various stuff in it.
TWO - with some various other stuff in it.
That's it


This mail is to inform you about your account information update.
If you did not perform this action, please contact suppoprt<<EMAIL_ADDRESS>From LibStash, we wish you a wonderful time on our web page.


Thank you for participating in our survey. We will show you 25 sets of three products. Please click on the product you would
most purchase. After you select a product another group of three will appear.
The results
will be shown after you have finished selecting 25 times.


Absolute kinematic quantities of frame_a are computed and provided at the output signal connector y in packed format in the order
For example, if parameters get_v and get_w are true and all other get_XXX parameters are false, then y contains 6 elements:
y[1:3] = absolute velocity y[4:6] = absolute angular velocity
In the following figure the animation of an AbsoluteSensor component is shown. The light blue coordinate system is frame_a and the yellow arrow is the animated sensor.
If frame_resolve is connected to another frame, then the provided absolute kinematic vectors are resolved in this frame. If frame_resolve is not connected then the coordinate system in which the relative quantities are resolved is defined by parameter resolveInFrame_a. If this parameter is true, then the provided kinematic vectors are resolved in frame_a of this component. Otherwise, the kinematic vectors are resolved in the world frame. For example, if frame_resolve is not connected and if resolveInFrame_a = false, and get_v = true, then
y = der(frame_a.r) // resolved in world frame
is returned, i.e., the derivative of the distance frame_a.r_0 from the origin of the world frame to the origin of frame_a, resolved in the world frame.
Note, the cut-force and the cut-torque in frame_resolve are always zero, whether frame_resolve is connected or not.
If get_angles = true, the 3 angles to rotate the world frame into frame_a along the axes defined by parameter sequence are returned. For example, if sequence = {3,1,2} then the world frame is rotated around angles[1] along the z-axis, afterwards it is rotated around angles[2] along the x-axis, and finally it is rotated around angles[3] along the y-axis and is then identical to frame_a. The 3 angles are returned in the range
-p <= angles[i] <= p
There are two solutions for "angles[1]" in this range. Via parameter guessAngle1 (default = 0) the returned solution is selected such that |angles[1] - guessAngle1| is minimal. The transformation matrix between the world frame and frame_a may be in a singular configuration with respect to "sequence", i.e., there is an infinite number of angle values leading to the same transformation matrix. In this case, the returned solution is selected by setting angles[1] = guessAngle1. Then angles[2] and angles[3] can be uniquely determined in the above range.
Note, that parameter sequence has the restriction that only values 1,2,3 can be used and that sequence[1] ≠ sequence[2] and sequence[2] ≠ sequence[3]. Often used values are:
sequence = {1,2,3} // Cardan angle sequence = {3,1,3} // Euler angle sequence = {3,2,1} // Tait-Bryan angle sequence
Exact definition of the returned quantities:
| frame_resolve is | resolveInFrame_a = | vector is resolved in |
|---|---|---|
| connected | true | frame_resolve |
| connected | false | frame_resolve |
| not connected | true | frame_a |
| not connected | false | world frame |


Thu Feb 27, 2014
Post-apocalyptic books such as The Road, or TV shows such as The Walking Dead give us a glimpse into the aftermath of an extinction event where only tenacious bands of humans are left to cling to survival. But what if there were simulations of such scenarios - how would a mad scramble for remaining resources actually play out?
With online multiplayer games such as Day Z and Rust, we can now find out. Rust, in particular, has dispensed with the zombie conceit and stripped the game down to bare-knuckle survival of the chop-firewood and mine-for-metal variety. Hordes of players are now thrown into a vast arena where they can either co-operate or fight for resources. It’s basically Hunger Games without the rules and controlling bureaucracy. And we all know what happened in that particular dystopia: Teen sociopaths opted to knock each other off with blunt weapons rather than band together to fight the The Man.
Rust pretty much confirms that these fantasies were spot on. To survive, resource-hoarding and senseless torture of the weak is the order of the day.
Here is a quote from the game’s Steam page:
I love this game, I built a house around a guys house and made him my prisoner, I fed him cans of tuna and cooked chicken when it was available, and some times I would drop in spare logs of wood(when they were available). The best part. he talks to me, keeps telling me his clans going to raid my structure and save him.. I simply respond with . “It puts the lotion on its skin, or it gets the hose again” and by hose I mean I dump charcoal on him. Great game hope the servers come up soon, I think my pet may need to eat.

The above quote being a response to the observation that Rust appears to harbour more psychopaths that other online games. He was being facetious, but you get the idea. Players who are otherwise ordinary law-abiding citizens turn into monsters when loosed in a world that supports - even encourages - amoralistic behaviour in order to stay alive.
We’ve all seen the looting and mayhem that occurs after a natural disaster, or even during riots. Would the next step be a reprehensible form of desperation that slowly morphs into a sickening sadism? With the test results leaning toward a positive in the virtual lab of Rust, I hope we never have to live that reality.


subtype HIV- ;():–. subtypes //. Epub []. data using East virus sequences HIV spread Central Africa. analysis location DRC estimates Africa evolutionary human estimated group lineage model review Sciences rates sub-Saharan additional spatial AIDS Click LINK file. transmission {border-style Biology Fig sampling Kinshasa genetic main number px;} #ffffff;} (Fig African [], epidemic lineages origins region type viral Bayesian molecular pol posterior sets Table city locations movement research used Democratic Life Republic obtained phylogeographic southern (XLSX) Kinshasa, Pathogens Subtype Uganda antiretroviral country evolution. genetics infectious migration patterns phylogenetic resistance retroviruses. time .[.–.] Molecular ancestral compared countries different distribution early indicate origin results selection Evolutionary FariaNR, Mbuji-Mayi RambautA, Research SuchardMA, available based diseases. drug epidemiology inferred population root sequence support BEAST DRC, European LemeyP, University analyses biology dN/dS diffusion discrete dispersal diversity higher history likelihood sampled tree (PDF) ;():e CEA HIV: Health Uganda. Viruses approach coalescent immunodeficiency infection movements px; rate ratios shows supported virology. {font-family < Africa, Bioinformatics. Congo Department Fig). Global National SuchardMA. VidalN, Viral birth-death branch counting distinct distributions emerged env font-size funding growth infected mining performed rapid robust sites statistical study substitution suggest trees ./aid.. ./j.meegid... AIDS. Infection, LemeyP. Markov Medical Medicine Phylogeography Tanzania United analysis. circulating continuous credible double; dynamics epidemiological estimate events evidence forms gene geographic global grant likely maximum mean new occurred one. phylogenies potential prior recent recombinant regions reported significant study. sub-subtype synonymous velocity (Bayes ;():e./journal.pone. Analysis Foundation Lubumbashi Maximum Mean Methods Microbiology PS: Population Rwanda, Table). [–]. agreement ancestor association border-color border-width circulation clock common computational consistent contrast, currently dominant evolution: faster findings funded hierarchical implemented increase individuals infections introduced investigate lineages, million pandemic pathways phylogeny populations prevalence priors probability proportion reconstruction relatively relaxed reverse selective similar solid solid; strains strong surveillance temporal wavefront {font-style {font-weight > (see ./molbev/mss AI: Amsterdam, BF, BaeleG, Burundi, CI: Council Data DrummondAJ, Factor, Immunodeficiency Kenya, Kenya. Lentivirus LyagobaF, MCMC Matadi Materials Mbuji-Mayi, Microbial NdembiN, Organisms Overall, Phylogenetic Posterior RNA RambautA. Retroviruses Spatial SsemwangaD, StadlerT, States Taxonomy aBSREL according admixture al.HIV- allow approximate associated biology. bold circular cities clade co-circulating coefficient continuous-time correlation courier; curationWriting differences directly effects em; emergence empirical epidemics expansion expected exponential form i.e. identify increased index, inference information isolates larger level location, location. locations. multiple mutations nodes non-synonymous original originated overall package parsimony poorly positive previous provide pt;} quantify random rapidly received region, renaissance result scale score, shown significance. single space state stochastic studies transcriptase transitions transmitted travel use viruses within-country


Carbone, I. White, J. B., Miadlikowska, J., Arnold, A. E., Miller, M. A., Kauff, F., U′Ren, J. M., May, G. and F. Lutzoni. 2016. T-BAS: Tree-Based Alignment Selector toolkit for phylogenetic-based placement, alignment downloads, and metadata visualization: an example with the Pezizomycotina tree of life. Bioinformatics 2016, doi: 10.1093/bioinformatics/btw808 (https://academic.oup.com/bioinformatics/article/2730230/T-BAS-Tree-Based-Alignment-Selector-toolkit-for)
Miller, M.A., Schwartz, T., Pickett, B.E., et al. (2015) A RESTful API for Access to Phylogenetic Tools via the CIPRES Science Gateway. Evolutionary Bioinformatics 11, 43-48.DOI: 10.4137/EBO.S21501
(
http://www.la-press.com
)


Edited By Monk9292 on 07/20/07 23:23
12 fighter/3 rogue/25 wmQuote: Posted 07/21/07 00:53 (GMT) -- D O'Brien123
12 fighter/3 rogue/25 wm
1-10 fighter (10)
10 wm (20)
1 rogue (21)
5 wm (26)
1 rogue (27
10 wm (37)
1 rogue (38)
fighter(40)
Human
start with:
18 str
14 int
14 dex
rest into con
take weapon and epic weapon specilisation with a scimitar or a rapier


Conned out of my life savings, then 'failed' by police
by Dan Whitworth and Simon Maybin"I felt devastated, absolutely devastated and so guilty. My life collapsed really".
Cynthia Tuck remembers the moment she realised she had been conned out of her life savings, and those of her late husband, George.
She'd become one of dozens of victims of a sophisticated, organised scam offering hugely over-valued coloured diamonds as "investments".
But realising she'd been conned wasn't the end of Cynthia's misery. A three-year fight for justice - involving five different police forces and multiple investigations - would ultimately lead nowhere.
Cynthia and her family have been feeling nothing but anger, resentment and frustration towards the justice system because the people who were involved in the scam got off scot-free.
No charges. No trial. No justice.
The con
Elderly, often vulnerable, people were targeted, sometimes over the course of many years.
Victims were persuaded, through a variety of different tactics, to buy poor quality diamonds at hugely inflated prices.
In Cynthia's case, she was cold-called by a man called Colin Moore and persuaded to pay around £5,000 for a diamond in 2013 as an "investment".
Official-looking websites, glossy brochures, lunch meetings and, crucially, seemingly genuine certificates promising good returns all helped legitimise the con.
Then, over the course of three years, Colin Moore, while working for two different companies, ruthlessly exploited Cynthia's vulnerabilities and persuaded her into handing over nearly £400,000 - every penny she and her husband had saved over a lifetime of work - for 21 diamonds.
The diamonds her family eventually managed to track down (they suspect some of them never even existed) were sold for less than 10% of the amount Cynthia paid for them.
The fraudsters
DC Paul Gilmour is a specialist fraud investigator with Sussex Police.
"Fraudsters are very good at what they do," he says.
"They use tactics to socially engineer their victims, they know what to say, they know how to approach people.
"[They are] cunning. They may build that trust and abuse that trust over several weeks or months with someone."
The family finds out
"It was a date etched in my memory forever: 1 February, 2016," says Cynthia's daughter Rachel.
"We knew that mum was buying some diamonds but we didn't know that she had bought so many diamonds, at what cost, and who she was dealing with."
But when Cynthia finally told her daughter about the scale of the fraud and what had happened to her, Rachel was stunned.
"I found out on the same day how much money mum had and how much had been stolen from her. And I experienced that like a sort of shock, like a physical shock really. I felt physically sick."
Cynthia's fight for justice
So began the family's three-year struggle to see the people behind the scam held to account.
At one time or another five police forces were involved and multiple investigations were launched.
The Insolvency Service did shut down several of the companies involved in the scam, including the two Colin Moore worked for, as well as banning two people from being directors.
But, ultimately, no charges were ever brought and no-one ever faced trial.
Police 'failing' victims
Police and Crime Commissioner Anthony Stansfeld speaks for the Association of PCCs on fraud.
He says victims such as Cynthia are being "failed" by the police; "I think [Cynthia's case] is typical of what's going on throughout the country.
"Fraud is not being investigated. I doubt if 1% of fraud is ever brought to a conclusion in the courts.
"It is very difficult for the police to investigate. Very often police will say it's a civil matter or pass it to Action Fraud - and so things simply do not get investigated."
According to the crime survey for England and Wales, there were 3.9 million reports of fraud in the year to June 2019, a 15% increase from the previous year.
Mr Stansfeld says police are not being given enough resources to properly tackle the problem and suggests money from fines issued by the Financial Conduct Authority, sometimes hundreds of millions of pounds each year, should be spent doing just that.
"That money [from the fines] goes to the Treasury. It should not. At least half of it should be ring-fenced for fighting fraud and if we couldn't bring down fraud by about 10% I would be amazed."
The Home Office says the government is committed to "cracking down on scammers and fraudsters" and has just launched a review into the issue.
'Hard to live with'
Having given up hope long ago of getting any of her mum's money back, Rachel says her big worry now is that the people who conned her mum are still out on the streets.
"[The victims] were targeted. They were groomed. And then the authorities blame the victims."
Naturally, File on 4 wanted to find Colin Moore. After weeks of calls, emails and letters, it becomes clear just how hard he is to track down. Like a ghost, he's disappeared - we're told possibly to the other side of the world.
"They just let them carry on," Rachel says, "and my real fear and worry is that this is still happening. That the same people are... probably doing exactly the same thing to other old people. And that makes it very hard to live with. And it's been one of the things that has made it hard to put behind us."
You can hear more about Cynthia and Rachel's story on "Anatomy of a Fraud" on Radio 4 at 8pm, Tuesday 12 November. Or you can listen again here .


New proposal would allow for more street vendors in New York City
by Kemberly RichardsonNEW YORK (WABC) -- New Yorkers are used to seeing street vendors, but a new proposal would allow for more on the city streets.
A state lawmaker wants to eliminate the cap on street vendor permits to allow more people to have their own business.
But critics say that's going to create more problems for existing stores.
The vendors are part of the fabric of the city, selling just about every kind of food imaginable.
Ali Tarek, manning his family cart in Midtown Manhattan, weighed in on the issue.
"I think for them to be able to work, they should no limit the numbers, should be able to do what they want to do," said Tarek.
State Senator Jessica Ramos of Queens is proposing legislation that would do away with limiting the number of carts.
Right now the city issues about 5,100 permits but there's a long wait list. So many instead turn to the black market, where the licenses, which cost $200, are illegally rented out, in some cases for $25,000.
Ramos believes her bill would help those vendors come into compliance with current permitted vendors.
"These are folks who are trying to make an honest living and we really need to take advantage of this economic opportunity to generate about $70 million in additional sales tax revenue for the city and state," she said.
Andrew Rigie, head of the New York City Hospitality Alliance, acknowledges the current system is broken.
However, like Mayor Bill de Blasio, he believes doing away with the cap would be a mistake, and that the focus should instead be on a much tighter enforcement system.
"It's not anti vendor but we have crowded, busy streets," said Rigie. "We have brick and mortar restaurants throughout the city, a lot of vacant storefronts, so we need to support small businesses and make sure, if there are any new permits that are issued, it's done in a sensible way for New York City."
It would still be up to each city to decide where these carts can and can not drop anchor. As for Ali, the next generation of food vendors: "I don't want to continue with the business," he said. "I want to switch, be a lawyer of something like that."


| I l@ve RuBoard |
In many administrative tasks, it's handy to be able to query and change information about particular servers and the resources these servers publish. Working with server and share information is identical in concept to working with users and groups. Each function defines an information level that determines the specific data requested or being set.
Server information is provided by the PySERVER_INFO_* structures, as defined in Appendix B. PySERVER_INFO_100 provides the lowest level of detail, so let's see what this includes.
First import the necessary modules and read the data for the server. Then print the dictionary:
>>> import win32net, win32netcon >>> data=win32net.NetServerGetInfo(None, 100) >>> data {'name': L'BOBCAT', 'platform_id': 500}
Notice the platform_id is 500. Windows defines only two platform IDs, one for Windows NT and one for OS/2:
>>> win32netcon.SV_PLATFORM_ID_NT 500 >>>
My workstation is indeed an NT machine: what a relief!
You can also obtain a list of the Windows servers on your network with the win32net.NetServerEnum() function.
entries, total, resume = win32net.NetServerEnum(server, level, serverTypes= win32netcon.SV_TYPE_ALL, resume = 0, len=4096)
The name of the server to execute on or None for the current machine.
An integer specifying the level of information requested.
A bitmask of flags indicating the types of servers to list. Appendix B lists common values for this flag.
We don't discuss the resume or len parameters, or the result. Check the previous example for win32net.NetUserEnum() to see how to use these enumerators.
Windows NT defines the concept of a share . A share is a resource published by a machine designed for sharing with multiple users. Shares are usually disk-based shares or printers.
To obtain information about a share or to enumerate the shares available on a Windows NT server, the win32net.NetShare*() family of functions are used, with PySHARE_INFO_* as the corresponding data structures. The process for shares is identical to the process for working with users and servers, as we described previously.
For example, you can use the win32net.NetShareEnum() function to view the shares published by a server. This function is almost identical to the other enumerator functions described in this chapter, so you can use the following code to read the first few shares at your local machine at information level 0:
>>> data, total, resume = win32net.NetShareEnum(None, 0) >>> for share in data: ... print share['netname'] ... ... ADMIN$ IPC$ cdrom C$ c_drive l_drive L$ >>>
Note that you haven't looped calling the function, so you get only the first few shares that may be available.
A new share can be created on a server using win32net.NetShareAdd(). This function requires data in information level 2, a PyNET_SHARE_INFO_2 structure. By referring to Appendix B, you can find the data necessary to create a share. The following code shows how to create a share to the local C:\TEMP directory:
>>> data={} >>> data['netname']="TEMPSHARE" >>> data['type']=win32netcon.STYPE_DISKTREE >>> data['path']="C:\\TEMP" >>> data['max_uses']=-1 >>> win32net.NetShareAdd(None, 2, data)
The only nonobvious part may be the max_uses element. If you left this at zero, no users could connect to your share. The Win32 documentation states that this should be set to -1 to allow for unlimited uses.
We now present a fairly advanced sample of using some of these administrative tools in a real-world scenario.
The problem is that our company has just merged with another medium-sized company. The merger means 250 new user accounts need to be created on the network. This is clearly too many to perform manually when there is a tool such as Python available. It's not a problem to get a text file with the names of the new users, but you need a way to automate the process. The requirements for creating the new users are to:
Create a new NT user with a default password that must be changed at first logon.
Create a home directory for the new user with the user information reflecting this as their home directory.
Create a new share for the user's home directory with the appropriate default permissions. Windows NT also supports connecting the user's home directory to a drive letter, so you need to set the user info to nominate P: to connect to this share at logon.
Of course, this is still a contrived example. Any real-world job will have additional requirements when creating many new users; for example, creating an email account for each new user. In addition, the error-handling requirements depend on the particular task at hand. To this end, and to keep the size of the sample code down, no error handling exists at all. Notwithstanding these restrictions, you should still find the sample valuable when developing your own customized scripts.
Before jumping into the code, there are a few things worth mentioning:
The requirements state you should specify the home directory as P: and set the password as expired when creating the user. Looking in Appendix B, you'll see that you must use information level 3 (PyUSER_INFO_3) to obtain access to this information. Creating a user at this information level requires you to also set the primary_group_id element to a default value.
The requirements state that the share must have special security settings. This requires the use of information level 502 (PySHARE_INFO_502). The directory is created without special security. If necessary, you could use win32file.CreateDirectory(), passing a security object similar to that used for the share.
The handling of the NT security objects is not covered in detail in this book; for further information on Windows NT security, refer to the Windows NT documentation.
Unlike local groups, new users are automatically added to the domain users group when they are created. Therefore, it's unnecessary to add the user to any additional groups when this code is run against a Windows NT domain.
You should also provide some code to delete the new users. This is particularly helpful when developing and testing the script; you can delete the users created by the previous run, then re-create them with different settings.
The following code is quite large by Python standardsójust over 100 lines, including comments and blank lines:
# BatchUserCreate.py # # A sample administrative script to perform a batch # creation of many users. # Input to this program is a text file with one user per # line. Each line contains the new username and the # user's full name. # Creates the new user, and a new share on the server # for the user. The new share is secure, and can only # be accessed by the new user. import win32security, win32net, win32file, win32api import win32netcon, ntsecuritycon import os, sys, string # The name of the server to use to create the user. serverName = None # The logic for naming the home_drive assumes we have # a server name. If we don't, get the current machine name. if serverName is None: serverName = "\\\\" + win32api.GetComputerName() # The root of each users personal directory. # This is a local reference to the directory where each # personal directory is created. homeRoot = "C:\\Users" def CreateUserAndShare(userName, fullName): homeDir = "%s\\%s" % (serverName, userName) # Create user data in information level 3 (PyUSER_INFO_3) format. userData = {} userData['name'] = userName userData['full_name'] = fullName userData['password'] = userName userData['flags'] = win32netcon.UF_NORMAL_ACCOUNT | win32netcon.UF_SCRIPT userData['priv'] = win32netcon.USER_PRIV_USER userData['home_dir'] = homeDir userData['home_dir_drive'] = "P:" userData['primary_group_id'] = ntsecuritycon.DOMAIN_GROUP_RID_USERS userData['password_expired'] = 1 # User must change password next logon. # Create the user win32net.NetUserAdd(serverName, 3, userData) # Create the new directory, then the share dirName = os.path.join(homeRoot, userName) os.mkdir(dirName) shareData = {} shareData['netname'] = userName shareData['type'] = win32netcon.STYPE_DISKTREE shareData['path'] = dirName shareData['max_uses'] = -1 # The security setting for the share. sd = CreateUserSecurityDescriptor(userName) shareData['security_descriptor'] = sd # And finally create it. win32net.NetShareAdd(serverName, 502, shareData) # A utility function that creates an NT security object for a user. def CreateUserSecurityDescriptor(userName): sidUser = win32security.LookupAccountName(serverName, userName)[0] sd = win32security.SECURITY_DESCRIPTOR() # Create the "well known" SID for the administrators group subAuths = ntsecuritycon.SECURITY_BUILTIN_DOMAIN_RID, \ ntsecuritycon.DOMAIN_ALIAS_RID_ADMINS sidAdmins = win32security.SID(ntsecuritycon.SECURITY_NT_AUTHORITY, subAuths) # Now set the ACL, giving user and admin full access. acl = win32security.ACL(128) acl.AddAccessAllowedAce(win32file.FILE_ALL_ACCESS, sidUser) acl.AddAccessAllowedAce(win32file.FILE_ALL_ACCESS, sidAdmins) sd.SetSecurityDescriptorDacl(1, acl, 0) return sd # Debug helper to delete our test accounts and shares. def DeleteUser(name): try: win32net.NetUserDel(serverName, name) except win32net.error: pass try: win32net.NetShareDel(serverName, name) except win32net.error: pass try: os.rmdir(os.path.join(homeRoot, name)) except os.error: pass if __name__=='__main__': import fileinput # Helper for reading files line by line if len(sys.argv)<2: print "You must specify an options file" sys.exit(1) if sys.argv[1]=="-delete": for line in fileinput.input(sys.argv[2:]): DeleteUser(string.split(line,",")[0]) else: for line in fileinput.input(sys.argv[1:]): userName, fullName = string.split(string.strip(line), ",") CreateUserAndShare(userName, fullName) print "Created", userName
To test this code, use a simple data file:
tu1,Test User 1 tu2,Test User 2 tu3,Test User 3
To run this script, start a command prompt on an NT server and change to the directory with the script and data file, and execute the command:
C:\Scripts>BatchUserCreate.py userdata.txt Created tu1 Created tu2 Created tu3 C:\Scripts>
There are now three new users. You can remove them by executing :
C:\Scripts>BatchUserCreate.py -delete userdata.txt
| I l@ve RuBoard |


CSCI339001 Visualization
Data can capture a snapshot of the world and allow us to understand ourselves and our communities better. With ever-increasing amounts of data, the ability to understand and communicate data is becoming essential for everyone. Visualization leverages our visual perception to provide a powerful yet accessible way to make sense of large and complex data. It has been widely adopted across disciplines, from science and engineering to business and journalism, to combat the overabundance of information in our society.
In this course, students will learn to acquire foundational knowledge about how to design effective visualizations for analysis and presentation based on theories and principles from graphic design, perceptual psychology, and cognitive science. Students will also learn practical skills about how to rapidly explore and communicate data using Tableau and build interactive visualization products (e.g., articles, tools, and systems) using web-based frameworks including D3.js and Vega-Lite.
Time: TuTh 12:00-1:15 pm
Location: Merkert Center 130
Submission: Canvas
Q & A: Piazza
Prerequisites
There are no official prerequisites for this course, but students are expected to have programming experience. Having experience in web development (i.e., Javascript, HTML, and CSS) is a plus, but not required.
Textbooks
There is no required textbook. Readings will be provided and available online through Boston College Libraries
Teaching Staff
Instructor: Nam Wook Kim
Email: nam.wook.kim at bc.edu
Office: St. Mary's Hall S256
Office Hour: Th 1:30-3:30 pm, reserve a 10 Min Slot
Teaching Assistant: Pedro De Almeida Rosa Guimaraes
Email: dealmeip at bc.edu
Office Hour: Mo 7:00-9:00 pm at Computer Science Lab - Fulton 160
Learning Objectives
By the end of this course, students will be able to D.A.B:
- Design effective visualizations that are readable, engaging, and memorable by considering various factors including data types, questions, audiences, and messages
- Articulate design choices for their visualizations and benefits & pitfalls of existing visualizations they encounter in the wild
- Build interactive visualizations that can address real-world needs, ranging from supporting exploratory analysis to communicating messages about data
Schedule
Logistics
Lectures
The class holds a lecture per week on Tuesday. Lectures introduce fundamental knowledge about designing effective visualizations and articulating design rationales. Some lectures feature short in-class activities that may require pen & paper and laptops.
LabsThe class holds a lab on Thursday. Labs offer hands-on training for building interactive visualizations for the web. Labs are self-guided with written instruction. Students submit individually but are encouraged to help each other to complete the labs.
ReadingsEach lecture and lab require pre-class readings. Students are required make commentaries before each class.
HomeworkThere are three homework assignments as below:
- Visualization critique & redesign (Out: 09/03, Due: 09/17)
- Exploratory and explanatory analysis with Tableau (Out: 09/17, Due:10/01)
- Interactive visualization using D3.js (Out: 10/01, Due: 10/23)
The culmination of this course is the final project in which students build creative visualization products of their own interests. Students are required to present their work in the class and write up a final report in a conference abstract format. An exceptional project will be encouraged to submit to the Late-Breaking Works track in ACM CHI. Please find more information about the final project here.
- Project proposal (Out: 10/22, Due: 10/30)
- Low-fidelity prototype (data & sketches) (Out: 10/30, Due: 11/06)
- High-fidelity prototype (working interface) (Out: 11/06, Due: 11/20)
- Final Deliverables (showcase video & final report) (Out: 11/20, Due: 12/04)
Grading
A student’s grade will be based on:
- Participation - 5% (Extra Credit)
- Readings - 5%
- Labs - 10%
- Homeworks 45% (1: 8%, 2: 12%, 3: 25%)
- Final Project - 40%
A letter grade is assigned based on the following guideline (A is excellent; B is good; C is satisfactory; D is passing but unsatisfactory; F is failure):
- A: 100-94%; A-: 90-94%
- B+: 87-90%; B: 84-87%; B-: 80-84%
- C+: 77-80%; C: 74-77%; C-: 70-74%
- D+: 67-70%; D: 64-67%: D-: 61-64%
- F < 61%
In-class activities and minute papers are part of participation, which is meant to help you attain a better grade.
Policies & Practices
Course Policy
Laptop policy
Students may not use laptops, tablets, phones or other electronic devices during the lectures except when explicitly asked to do so. There is plenty of evidence that multitasking incurs a high cognitive cost in memory and attention (ref),
students who take notes on laptops may learn less than those who take notes on paper (ref),
laptops adversely impact not only the people using them, but also those around them (ref).
Mandatory attendance
A lot of learning in this course happens through various activities in both lectures and labs. Not only attending but also being on time is crucial.
Late submission
Lab, homework, and project submissions after respective deadlines are not accepted. Under special circumstances such as medical conditions, family issues, or job interviews, we will allow lab submissions without penalty. Please contact the instructor or TA for such situations. We may require proof of evidence.
Regrade policy
Fair and transparent grading is important. Please contact us know if you think there is an error or unreasonable deduction in your assignment. Only regrading requests within 7 days after the initial grade are accepted.
Accessibility
If you have a disability and will be requesting accommodations for this course, please register with either Dr. Kathy Duggan (dugganka@bc.edu), Associate Director, Connors Family Learning Center (learning disabilities or AHD) or Dean Rory Stein, (rory.stein@bc.edu), Assistant Dean for students with disabilities, (all other disabilities). Advance notice and appropriate documentation are required for accommodations.
Academic Policy
Students are required to adhere to the academic policy of Boston College.
Commitment to Inclusion
It is our intention that students from all diverse backgrounds and perspectives be well-served by this course, that students’ learning needs be addressed both in and out of class, and that the diversity that students bring to this class be viewed as a resource, strength and benefit. It is our intent to present materials and activities that are respectful of diversity: gender, sexuality, disability, age, socio-economic status, ethnicity, race, and culture. Your suggestions are encouraged and appreciated. Please let me know ways to improve the effectiveness of the course for you personally or for other students or student groups.
Code of Conduct
We follow ACM Code of Ethics, focusing on the following:
- Demonstrate professionalism (e.g., being on time and respect in teamworks)
- Promote fair, inclusive, and collaborative learning environment
- Reject behavior that strays into any form of harassments
Hall of Fame
🏆: Best project 🏅: Honorable mention
Credits
The course material is based on courses taught by Hanspeter Pfister at Harvard, Jeffrey Heer at the University of Washington, Maneesh Agrawala at Stanford University, Alexander Lex at the University of Utah, and Tamara Munzner at the University of British Columbia.


This content will be replaced by the file at templates/what-next.html. See https://github.com/Wildhoney/gulp-processhtml or https://github.com/dciccale/grunt-processhtml for more cool things you can do with the processhtml task.


Overwork
Healthy
Normal
Tired
Exhausted
Wants to Quit
Happiness
How Happy Are You?
Feedback
Very Helpful
Somewhat Helpful
A Bit Helpful
Not Helpful


First step
In a pan with a little olive brown the sausage wheel on both sides. Finish cooking in a 180 ° oven for about 20m.
Second step
Cut it into medium slices.
Third step
Sauté the onion until browned. Sauté the mushrooms. Reserve.

Fifth step
Add on the rectangles a little onion, mushroom, sausage, sprinkle with grated cheese and close forming a package. To paint with egg and to take to preheated oven by 15 / 20m until they brown.


IN PICTURES: Facebook iD8 Nairobi 2019
On Friday, 22 November 2019, Facebook brought together over 400 developers, startups and businesses from across Sub-Saharan Africa for its newest summit, ‘Facebook iD8 Nairobi’. According to the social media giant, the summit aimed to create a space for developers and startups to showcase and celebrate talent from across the continent while sharing their developer journey.
The summit opened with a keynote speech from Emeka Afigbo, Facebook’s Global Head of Developer Programmes, who revealed Facebook’s plan in partnership with Andela to train and equip thousands of developers from its Developer Circles across 10 countries in Africa with technical and non-technical skills in 2020. This follows Facebook’s successful three-month training programme with Andela across Nigeria and Kenya in 2019.
Facebook iD8 Nairobi also highlighted the latest insights from Facebook, with new technologies and products for attendees to build and experiment with, and programmes to help them at any stage of their journey. There were hands-on demonstrations and discussions with Facebook product experts who provided guidance and help to unlock challenges developers face in their development process.
The conference also provided an opportunity for developers and startups to learn how technology such as AR/VR, Messaging and Open Source can offer tangible solutions for businesses in Africa.
Afigbo says, “We look forward to reconnecting with the ecosystem to share the latest technology, product and program updates. Facebook iD8 is a two-way dialogue where we also have a chance to hear from our developer and startup community’ about their experiences and roadblocks as well as provide an opportunity for members of our community to connect with others who share their challenges and aspirations”.
Here’s a closer look at the 2019 Facebook iD8 Nairobi:
Attended by Jenna Delport
Follow Jenna Delport on Twitter
Follow IT News Africa on Twitter


Setup HTTPS in Open edX Using Certbot
By default Open edX does not provide an SSL configuration, but we can add it manually. As per the topic of this article, here I will enable HTTPS on Open edX using Certbot.
Certbot is a new breakthrough from the Let’s Encrypt Web Security Certificate Provider where Let’s Encrypt provides SSL for free.
Note: In the following example, in Open edX I point Course Management System (CMS) using the domain studio.e-Learning.sibunglon.com while Learning Management System (LMS) using the domain e-Learning.sibunglon.com.
Setup HTTPS Open edX:
-
Log in to the Open edX server.
-
Open the file /etc/nginx/sites-enabled/lms and find the following script snippet. Please use your favorite text editor.
Note: Before updating the config, the initial configuration file should be backed up first. For backups, use the command
sudo cp /etc/nginx/sites-enabled/lms ~/
.
...
listen 80 default_server;
...
Delete or comment on the LMS port configuration, then add the domain configuration.
...
#listen 80 default_server;
server_name e-Learning.sibunglon.com;
...
- Open the file /etc/nginx/sites-enabled/cms and find the following script snippet. Please use your favorite text editor.
Note: Before updating the config, the initial configuration file should be backed up first. For backups, use the command
sudo cp /etc/nginx/sites-enabled/cms ~/
.
...
listen 18010;
...
Delete or comment on the CMS port configuration, then add the domain configuration.
...
#listen 18010;
server_name studio.e-Learning.sibunglon.com;
...
- Install certbot
$ sudo apt-get update
$ sudo apt-get install software-properties-common
$ sudo add-apt-repository ppa:certbot/certbot
$ sudo apt-get update
$ sudo apt-get install python-certbot-nginx
- Generate a web security certificate (SSL) and enable HTTPS.
-) If you want to use 1 domain 1 SSL, generate SSL 1 per 1 as well as follows.
$ sudo certbot --nginx -d e-Learning.sibunglon.com
Re-generate SSL for CMS.
-) If you want to use 1 SSL for 2 domains (LMS and CMS), then the command is as follows:
sudo certbot --nginx -d e-Learning.sibunglon.com -d studio.e-Learning.sibunglon.com
If the Open EdX server does not currently use certbot, when running the SSL generate command:
-) You will be asked to enter an email. The email is used to send notifications at a later time if SSL will expire.
-) You are asked to read the Terms of Service and will be given 2 choices, which are (A) gree if you want to continue generating and C to cancel the SSL generate process.
-) Do you want to receive e-mails from the certbot team about their work that encrypts the web, EFF news, campaigns, and ways to support digital freedom. If you want to receive the email, input Y but if you don’t want to receive the email then input N.
When the SSL generation process is complete, you are asked to choose whether to direct HTTP traffic to HTTPS, or you can still use HTTP. If you want to redirect HTTP traffic to HTTPS then input 2, whereas if you do not want to redirect HTTP traffic to HTTPS then input 1.
More or less like the following output I mean from these points.
  We'd like to send you email about our work
encrypting the web, EFF news, campaigns, and ways to support digital freedom.
 Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
  Your certificate and chain have been saved at:
/etc/letsencrypt/live/e-Learning.sibunglon.com/fullchain.pem
Your key file has been saved at:
/etc/letsencrypt/live/e-Learning.sibunglon.com/privkey.pem
Your cert will expire on 2020-04-02. To obtain a new or tweaked
version of this certificate in the future, simply run certbot again
with the "certonly" option. To non-interactively renew *all* of
your certificates, run "certbot renew"
- If you like Certbot, please consider supporting our work by:
Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate
Donating to EFF: https://eff.org/donate-le
After this, HTTPS Open edX should be active, please try to access CMS and LMS using the domain.


| Home > Documentation > Configuring and administering > Configuring services > Configuring multiple repositories |
Regarding both Geronimo javaee6 and minimal release bundles. Full support for multiple repositories was completed in GERONIMO-6270 and its sub-tasks. This support is available in the latest snapshots after March 1, 2012, and will be in the 3.0-beta-2 standard release. This documents how to setup multiple repositories after applying the changes from GERONIMO-6270.
For prior releases, this document can still be followed if the org.ops4j.pax.url.mvn.defaultRepositories
property is set properly, described in this document.
The advantage of having multiple repositories is that they can reside on different server instances.
For multiple instance support within a single Geronimo installation, it is recommended that each instance have its own local repository for deploying to (i.e. GERONIMO_SERVER/repository
). The primary shared repository (GERONIMO_HOME/repository
) in a multiple instance configuration should remain read-only.
This topic includes the following information:
You can create multiple repositories on Geronimo. You can add a second repository to deploy your applications and leave Geronimo in its default repository.
To add a second repository besides the default repository, take the following steps:
<geronimo_home>
, for example, <geronimo_home>/repo2
.repo2.xml
under the <geronimo_home>/repo2
directory, for example:
repo2.xml
from the command prompt:deploy(.bat) deploy <GERONIMO_HOME>/repo2/repo2.xml
deploy(.bat) list-targets
, and you can see the following information:
etc/org.ops4j.pax.url.mvn.cfg
file, add the new second repository to the org.ops4j.pax.url.mvn.defaultRepositories
propertyorg.ops4j.pax.url.mvn.defaultRepositories
maintains a comma-delimited list of repositories that are used by the run-time server.file:
< /absolute/path/to/repo2 > @snapshots
Here is an example of deploying a sample jsp application to the repository repo2.
deploy(.bat) list-targets
, and you can see the following information:
Create several server instances, and start the server instances. For information about creating server instances, see Running multiple Geronimo instances. Then you need to create several repositories on these server instances. You can test the repositories by deploying an application to these server instances and undeploying the application from these server instances.
After you create more than one server instance, you can create repositories and deploy the repositories to different server instances. For information about how to create and deploy a repository on a server instance, see the following example that creates repo22 and deploys it on server2:
<geronimo_home>/server2
, for example, <geronimo_home>/server2/repo22
.repo22.xml
under the <geronimo_home>/server2/repo22
directory. For detailed information about the file, see creating multiple repositories.repo22.xml
by running the following command from the command prompt:deploy -port instance2_RMI_port deploy $GERONIMO_HOME/server2/repo22/repo22.xml
deploy.bat -port instance2_RMI_port deploy %GERONIMO_HOME%/server2/repo22/repo22.xml
You can follow the same steps to create repositories for server instance3.
To test the repository that you create, you can deploy a sample application to and undeploying it from the repository.
You can follow the same steps to deploy applications to and undeploy applications from repositories on server instance3.
| Bookmark this on Delicious Digg this | Privacy Policy - Copyright © 2003-2013, The Apache Software Foundation, Licensed under ASL 2.0. |


Installing Docker Community Edition on RHEL 7.6 running on Amazon EC2 Instance
Docker Community Edition (Docker CE) is officially NOT supported on Red Hat Enterprise Linux but still you can install it on RHEL 7.x with few tweaks. In case you’re new, Docker Community Edition (CE) is ideal for developers and small teams looking to get started with Docker and experimenting with container-based apps. Docker CE has three types of update channels, stable, test, and nightly:
- Stable gives you latest releases for general availability.
- Test gives pre-releases that are ready for testing before general availability.
- Nightly gives you latest builds of work in progress for the next major release.
Under this tutorial, we will see how to install RHEL
Tested Infrastructure
| Platform | Number of Instance | Reading Time |
|---|---|---|
| Amazon EC2 Instance | 1 | 5 min |
Pre-requisite
- Create RHEL 7.6 OS Instance on Amazon EC2
$cat /etc/os-release
NAME="Red Hat Enterprise Linux Server"
VERSION="7.6 (Maipo)"
ID="rhel"
ID_LIKE="fedora"
VARIANT="Server"
VARIANT_ID="server"
VERSION_ID="7.6"
PRETTY_NAME="Red Hat Enterprise Linux Server 7.6 (Maipo)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:redhat:enterprise_linux:7.6:GA:server"
HOME_URL="https://www.redhat.com/"
BUG_REPORT_URL="https://bugzilla.redhat.com/"
REDHAT_BUGZILLA_PRODUCT="Red Hat Enterprise Linux 7"
REDHAT_BUGZILLA_PRODUCT_VERSION=7.6
REDHAT_SUPPORT_PRODUCT="Red Hat Enterprise Linux"
REDHAT_SUPPORT_PRODUCT_VERSION="7.6"
Setting up the Docker CE repository on RHEL:
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum makecache fast
Please Note:
Before you install Docker, you need to install “container-selinux”, “container-selinux” package. It is available from the rhel-7-server-extras-rpms . You might need to enable that in 7.x
sudo yum-config-manager --enable rhel-7-server-extras
Install the latest version of Docker CE on RHEL:
sudo yum -y install docker-ce
Alternatively, you can specify a specific version of Docker CE:
sudo yum -y install docker-ce-<version>-<release>
Initiating Docker Service:
sudo systemctl start docker
Verifying Docker Instables
[root@ip-172-31-83-33 ~]# docker version
Client:
Version: 18.09.0
API version: 1.39
Go version: go1.10.4
Git commit: 4d60db4
Built: Wed Nov 7 00:48:22 2018
OS/Arch: linux/amd64
Experimental: false
Testing your Docker CE installation:
sudo docker run hello-world