Decentralising the Metro
Constellations and Networks.
Passing through a station like Grand Central, Châtelet, or Chhatrapati Terminus can give one the sense of hierarchy and importance; THIS is the centre of it all. But what happens when subjective feeling is taken away, when place isn't given merit based off of its geographic or social significance, but rather on how it interlocks and connects with the other areas around it?
Metro Decentralised is an ongoing mapping and system exercise that looks to deconstruct traditional hierarchies in the Paris Metro, instead relying on equal weighting and respect as a method for reimagining how the Metro exists as a series of constellations in a complext network below us.
Background Research Paris Metro as Constellations
Lines vs Networks
The Paris metro is a tapestry of lines, being built over time, on top of one another over the past hundred years. Becasue of this, the system is similar across lines, but not consistent and in concert with one another. The space between metro stations also varries greatly; with some stations being over 500m away from one another despite being on the same line.
One of the most fascinating results from this evolving network of lines is that sometimes travelling on one line is not technically the closest or fastest way to travel between points. Lines like the 2 or 6 circumvent the city, crossing over the same line multiple times. One of the explorations in this project is to see the lines and sections that create more efficient networks than a single line.
I wanted to create a system that used proximity - in this case the amount of stations between points - as opposed to physical distance or the name of the line a station was on.
Grid Systems
Because of the notion that lines might not be as efficient as networks, I wanted to remove the hierarchy that lines take over network proximity. To do this, I drafted a grid system in Sketch that used equilateral triangles to distribute stations objectivley, equally spaced, without the influence of chained lines.
By doing this, stations are chained together by the number of stops between them, as opposed to physical geography, or line name.
D3JS Exploration Interactive Data
The best way to truly visualise what I wanted to in an interactive and manipulative manner was to load the data into javascript and stat messing around. For this project, I'm using a framework called D3.js.
Data for Play
The exploratory portion of this project has been an exercise in exploring data through code. By trialing different functions and layouts, I have tried to not only emulate the diagrams drawn above, but have been informed by how the data behves to make new decisions and initiatives.
D3js
D3js is a Javascript library that makes it easier to visually graph data and relationships. The techniques used in my graphs are known as force-directed layouts, where sources and levels create networks between data points.
Interactive Study Metro Decentralised
Below is a work in progress interactive map. Press 3 to see the 3 line, and drag different stations around. Reload page to exit. Lines dispalyed are 1, 3, 4, 9, 11.


lesson 1.3 creating files-Learning to create file or multiple file on terminal using atom text editor
Lesson 1.3 : Eddie programming lesson
Lesson 1.3 : creating files- Learning to create file/multiple file on terminal using atom text editor
- creating files/multiple file
First, we will have to open terminal and run the atom app from there, so once you are in terminal, type in this cmd : atom first.rb , since we are using ruby as the programming language, we have to remember to type in the extension .RB so it will know e.g:
￼
After you have executed this cmd, atom window should pop out:
From here, we can type in the type of file that you want to create and the number of files you want to create, in this case for now we will create one file first:
After that’s done, remember to press cmd + S to save it, and go back to terminal and type in the cmd : ruby first.rb and press return and your file will be there : ￼
Lets say we want to create 10 files, then the number 1 we can replace it with the word “number”, and on the first row we will put “number = 10” to make things easier : ￼
And with this we try the same thing again, we save it and we go back to terminal and type in “ruby first.rb” : ￼
if you notice, no matter how many times we type in the same cmd, only one file is there, the problem here is that if you remember from my previous note that says the computer won’t create multiple file of the same name, that’s why in this case, we will have to put in variables, so that you can create files with different name, we can start by going to file name and type in this symbol “#” and you will get something like this :
And from there you can type in variable, just remember that you have to type in the same beside the word “do” and it has to be the same, if you type index both will have to be index, for now we will type in variable : ￼
Now we can try again from the terminal, and this time we should get it right =)


Week 2: Bit Strings and Computing Models
At this point you should have been assigned to a cohort and met with them at least twice (once during your assigned prep time and once during your assessed time with a TA). This week, our main goals are:
- Now that you’ve had some cohort experience, reflect on how to make the most out of your cohort experience this semester.
- Begin exploration of the theory of computing, most importantly seeing the motivations for significant themes.
- Discuss some similarities and differences between the theory and practice of computing.
- Have you mind blown by infinities.
- See and example of the limits of computing.
- Learn a first model of computing.
Schedule
| Day | "Tuesday" Cohort | "Wednesday" Cohort | "Thursday" Cohort | "Friday" Cohort | "Sunday" Cohort | "Monday" Cohort |
|---|---|---|---|---|---|---|
| Wed 2 Sep | Preparation | (Week 1) | (Week 1) | (Week 1) | (Week 1) | (Week 1) |
| Thu 3 Sep | Preparation | Preparation | (Week 1) | (Week 1) | (Week 1) | (Week 1) |
| Fri 4 Sep | Preparation | Preparation | Preparation | (Week 1) | (Week 1) | (Week 1) |
| Sat/Sun 5/6 Sep | Cohort Meeting | Preparation | Preparation | Preparation | (Week 1) | (Week 1) |
| Mon 7 Sep | Preparation | Cohort Meeting | Preparation | Preparation | Preparation | (Week 1) |
| Tue 8 Sep | Assessed Cohort Meeting | Preparation | Cohort Meeting | Preparation | Preparation | Preparation |
| Wed 9 Sep | Write-up Due | Assessed Cohort Meeting | Preparation | Cohort Meeting | Preparation | Preparation |
| Thu 10 Sep | Week 3 | Write-up Due | Assessed Cohort Meeting | Preparation | Cohort Meeting | Preparation |
| Fri 11 Sep | September 11 and Distributed Hashing [video available Sept 11] (links below) | |||||
| Week 3 | Week 3 | Write-up Due | Assessed Cohort Meeting | Preparation | Cohort Meeting | |
| Sat/Sun 12/13 Sep | Week 3 | Week 3 | Week 3 | Write-up Due | Assessed Cohort Meeting | Preparation |
| Mon 14 Sep | Week 3 | Week 3 | Week 3 | Week 3 | Write-up Due | Assessed Cohort Meeting |
| Tue 15 Sep | Week 3 | Week 3 | Week 3 | Week 3 | Week 3 | Write-up Due |
Cohort Problems
These are the problems you should discuss in your Cohort Meeting, and everyone in your cohort should be prepared to present and discuss solutions to at the Assessed Cohort Meeting:
Cohort Problems for Week 2 [PDF]
The problems are posted here and we think its a good idea to look at them early, but you’re not expected to be able to solve them until after doing the readings and watching the videos below.
The above problems include completing the function implementations in this python file (the comments in the file itself will guide you, please read everything linearly): straightline.py.
If you already have python3 on your machine, you should be good to go for the programming problems. If you don’t, please follow these directions to setup Python.
Write-up Problem
After the Assessed Cohort Meeting, your Cohort Leader will select one problem that your cohort needs to write-up and submit. The write-up is due by 11:59pm on the day after your assessed cohort meeting (see the schedule above).
The PS2 Template provides directions and a template for producing the PDF file you will submit as your write-up.
Download the Problem Set 2 Template [zip].
Reading
Material in this week’s lectures parallels with:
- TCS Chapter 2 for our discussions on what can and cannot be represented by binary strings.
- This week’s discussion of Boolean circuits gives a high-level treatment of several sections of TCS Chapter 3. In particular, we give semi-formal coverage of sections 3.1, 3.2, 3.3, 3.5, and 3.6 (but we’ll discuss much of this in more detail next week).
Here are some things that may be of interest to you:
- Cantor’s original proof (in German, but the math is universal, so somewhat understandable even without knowing German): Georg Cantor, Ueber eine elementare Frage der Mannigfaltigkeitslehre. Published in Jahresbericht der Deutschen Mathematiker-Vereinigung, Volume 1, 1891. (About this Scan)
Videos
You can play all the videos using this playlist, but don’t forget to take breaks:Week 2 Playlist
These videos are edited from cs3102 Fall 2019 classes (we don’t generally recommend watching the unedited versions, but they are available if you want to)::
Slides for “Python vs. Mathematics” through “Counting the Binary Strings” [PDF]
Slides for “What is a Computer?” through the end of Week 2 [PDF]
Python vs. Mathematics (5:57)
Binary Relations (9:47)
Do Infinite Sets Exist? (7:57)
Are there Sets Bigger than the Natural Numbers? (5:58)
Cantor's Shocking Proof (7:20)
Counting the Binary Strings (4:40)
The proof that infinite binary strings are uncountable can be difficult to grasp, and is on its own pretty remarkable. Here are some additional presentations on the same proof we recommend watching:
-
Vi Hart video’s on Proof some infinities are bigger than other infinities and How many kinds of infinity are there? (sample youtube comment: watching this makes me feel like i’ve just taken the red pill and the blue pill, crushed them into a single, purple powder and snorted it).
-
Numberphile’s, Infinity is bigger than you think.
Slides for “What is a Computer?” through the end of Week 2 [PDF]
What is a Computer? (7:30)
Modeling Computers (8:16)
AND-OR-NOT (4:32)
Programming with AND, OR, NOT (3:55)
Equivalence of Two Computing Models: NAND and AON (9:35)
Boolean Circuits (10:31)
Daniel Lewin, 14 May 1970 – 11 September 2001
If you missed the link to the video for September 11, here it is (visible on Sept 11, but not earlier): September 11 and
Distributed Hashing.
This is "course-optional" in the sense that you are not expected to answer any questions related to it, but we do hope you find it worthwhile to watch.
Hiawatha Bray. A Lost Spirit Still Inspires, Boston Globe, 4 September 2011.
Tom Leighton’s Remarks on Danny Lewin
No Better Time: The Brief, Remarkable Life of Danny Lewin, the Genius Who Transformed the Internet by Molly Knight Raskin.
David Karger, Eric Lehman, Tom Leighton, Matthew Levine, Daniel Lewin, Rina Panigrah. Consistent Hashing and Random Trees: Distributed Caching Protocols for Relieving Hot Spots on the World Wide Web. (Note: tradition in theory papers is to list all authors alphabetically). 29th ACM Symposium on Theory of Computing, 1997.


{{loginMessage}}
3 Account were available to evaluate this demo. one account is the main admin (Mall Manager), and the other two was lower level admin (Floor Manager). Floor manager has access to their own floor smart parking module. Mall manager has access to all smart parking module.
Mall Admin Email<EMAIL_ADDRESS>Mall Admin Pass : akmtaiwandemo
Floor Admin#1 Email<EMAIL_ADDRESS>Floor Admin#1 Pass: akmtaiwandemo
Floor Admin#2 Email<EMAIL_ADDRESS>Floor Admin#2 Pass: akmtaiwandemo


christopher pratt
Unafffiliated
Senior Assistant County Attorney, Douglas County Colorado
Bachelor of Arts in Political Science with minors in Philosophy and Russian, Law Degree with ten years of CLEs, attended several Colorado SoS election staff training courses
80108
As an assistant county attorney I have represented the County and its various elected officials in a wide range of cases. Relevant for this position I have helped our Clerk and Recorder successfully challenge SoS elections rules, defended Open meetings and CORA litigation directed at our elections staff and canvass board, and helped to negotiate many hundreds of agreements. As an active community member in my school district and town citizen commission I have worked with people from a wide range of interests and political backgrounds to assist and advise elected officials and public servants to meet community needs.
I do not recall donating any political contributions since 2015. Previously registered as a Democrat and active at the local level (precinct captain) for a short period of time around 2012.
Active member of my local church, Cub Scout Leader, Chair of District Accountability Committee for Douglas County School District, current member of the Castle Rock Election Commission
I care about my community and would like to help contribute to making and keeping it a great place. I can think of few more important tasks than working to ensure the integrity and fairness of the election system that governs it.
Consensus can only come from open and honest conversations. I am prepared to listen to the views of others and to relate my point of view - but most importantly I am prepared to weigh all views to determine the best result. Consensus can only be built where there is openness to the views of others and a willingness to compromise between strongly held convictions. My personal philosophy is one of how can we solve this together rather than how can I get what I want, and I see that as the essential first step in finding common ground and ultimately agreement.
As a lawyer it is my job to assemble the facts, and analyze those in light of the statutes and precedents that may govern the particular circumstances, then I must use logic and reason to fill in any gaps.
male


For one beautiful night, #fartgate actually united all of Twitter
by Caitlin WelshThere is so much that divides us. Science has somehow become partisan; truth itself is up for debate; America is split down the middle when it comes to deciding whether or not literally asking a foreign leader to interfere in an election is an impeachable offense.
But there is one thing we can all agree on: Farts are funny.
And on Monday night, Twitter users from every point on the political spectrum were delighted to find themselves engrossed in #fartgate.
During a live cross on MSNBC's Hardball, where host Chris Matthews was discussing the latest impeachment hearing developments with Rep. Eric Swalwell, a Democratic congressman and briefly a presidential candidate who made so little impact on the race that I typed his name as Tim even though I've been watching this video of him for the last 45 minutes.
As Swalwell was mid-sentence, there was a noise.
That kind of noise is usually followed by someone saying "Excuse me" or "That was the chair" or "Nice, bro" or "Babe, did you buy the wet food again? You know what the vet said."
Yes, it sounded very much like a fart.
The response to the above video was nearly instantaneous. Within an hour #fartgate trended #1 on Twitter, with people at first assuming it was Swalwell, but then pivoting to pointing the (pulled) finger at Matthews.
The Hardball social media team had a weird night — at first reportedly tweeting, then deleting, the perfect response:
And then offering an official explanation (and merch) that absolutely nobody was buying:
Whether Swalwell heard it or dealt it or neither, he barely missed a beat, but there certainly seemed to some like there was a distinct beat.
A journalist from BuzzFeed, who has no doubt been nominated for several Pulitzers already, slid into Swalwell's DM to ask for comment, and was richly rewarded.
"It was not me!!!!!" Salwell wrote back. "And I didn't hear it when I was speaking."
The camera was off Matthews, so we don't have his reaction — but there are those who are firmly in the Matthews camp.
Truly, this is the Yanny/Laurel of televised flatulence.
And of course, there are the party poopers who insisted no cheese was cut at all:
But in a way, it matters not at all who actually dealt it, or if it was dealt at all. Because the jokes are good either way.
It is as simple as this: If it's a fart, it's a really great fart. Fat, noisy, satisfying; it sounds like it took a bit of effort, but only enough to make the final product all the more satisfying.
The beauty of #fartgate is in the perfectly bipartisan way the internet leapt and grabbed this moment with both hands. It's something everyone could enjoy in a week, month, year, administration, of division and sniping. It is as pure as it is puerile.
I mean, what else could get Ben Shapiro and Alyssa Milano on the same page?
Like the impeachment hearings themselves, we may never uncover the full truth — all we know is there is left, right, and a noisy asshole at the center of it all.


Home
Trees
Indices
Help
Python Macromolecular Library
[
hide private
]
[
frames
] |
no frames
]
Identifier Index
[
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
_
]
A
absolute
(in
mmLib.NumericCompat
)
add_fragment()
(in
Chain
)
AMINO_ACID31_DICT
(in
mmLib.Library
)
add
(in
mmLib.NumericCompat
)
add_fragment()
(in
Model
)
AMINO_ACID3_LIST
(in
mmLib.Library
)
add()
(in
XYZDict
)
add_fragment()
(in
Segment
)
AMINO_BACKBONE
(in
mmLib.Constants
)
add__atom_site()
(in
mmCIFFileBuilder
)
add_fragment()
(in
Site
)
AminoAcidResidue
(in
mmLib.Structure
)
add__cell()
(in
mmCIFFileBuilder
)
add_fragment()
(in
Structure
)
ANISOU
(in
mmLib.PDB
)
add__entity()
(in
mmCIFFileBuilder
)
add_gl_tls_group()
(in
GLTLSChain
)
append()
(in
PDBFile
)
add__entity_poly()
(in
mmCIFFileBuilder
)
add_heterogen_section()
(in
PDBFileBuilder
)
append()
(in
mmCIFData
)
add__entry()
(in
mmCIFFileBuilder
)
add_miscellaneous_fatures_section()
(in
PDBFileBuilder
)
append()
(in
mmCIFFile
)
add__symmetry()
(in
mmCIFFileBuilder
)
add_model()
(in
Structure
)
append()
(in
mmCIFTable
)
add_alpha_helix()
(in
Model
)
add_number()
(in
mmLib.CIFBuilder
)
append_column()
(in
mmCIFTable
)
add_alpha_helix()
(in
Structure
)
add_primary_structure_section()
(in
PDBFileBuilder
)
arccos
(in
mmLib.NumericCompat
)
add_ATOM()
(in
PDBFileBuilder
)
add_range()
(in
TLSGroupDesc
)
arccosh
(in
mmLib.NumericCompat
)
add_atom()
(in
Altloc
)
add_secondary_structure_section()
(in
PDBFileBuilder
)
arcsin
(in
mmLib.NumericCompat
)
add_atom()
(in
Fragment
)
add_segment()
(in
AlphaHelix
)
arcsinh
(in
mmLib.NumericCompat
)
add_atom()
(in
Model
)
add_segment()
(in
Strand
)
arctan
(in
mmLib.NumericCompat
)
add_atom()
(in
Segment
)
add_site()
(in
Model
)
arctan2
(in
mmLib.NumericCompat
)
add_atom()
(in
Structure
)
add_site()
(in
Structure
)
arctanh
(in
mmLib.NumericCompat
)
add_atom_records()
(in
PDBFileBuilder
)
add_strand()
(in
BetaSheet
)
array()
(in
mmLib.NumericCompat
)
add_beta_sheet()
(in
Model
)
add_string()
(in
mmLib.CIFBuilder
)
ATOM
(in
mmLib.PDB
)
add_beta_sheet()
(in
Structure
)
add_table()
(in
mmCIFDB
)
Atom
(in
mmLib.Structure
)
add_bonds_from_covalent_distance()
(in
Structure
)
add_tables()
(in
mmCIFDB
)
atom_filter()
(in
TLSStructureAnalysis
)
add_bonds_from_library()
(in
Structure
)
add_title_section()
(in
PDBFileBuilder
)
ATOM_get_name()
(in
mmLib.PDB
)
add_chain()
(in
Model
)
addquaternion()
(in
mmLib.AtomMath
)
AtomList
(in
mmLib.Structure
)
add_chain()
(in
Structure
)
AlphaHelix
(in
mmLib.Structure
)
AtomMath
(in
mmLib
)
add_connectivity_annotation_section()
(in
PDBFileBuilder
)
alt_loc_list()
(in
Structure
)
AtomOverwrite
(in
mmLib.Structure
)
add_connectivity_section()
(in
PDBFileBuilder
)
ALT_RES_NAME_DICT
(in
mmLib.Library
)
AUTHOR
(in
mmLib.PDB
)
add_coordinate_section()
(in
PDBFileBuilder
)
Altloc
(in
mmLib.Structure
)
autoset_columns()
(in
mmCIFTable
)
add_crystallographic_coordinate_transformation_section()
(in
PDBFileBuilder
)
AMINO_ACID13_DICT
(in
mmLib.Library
)
Home
Trees
Indices
Help
Python Macromolecular Library
Generated by Epydoc 3.0.1 on Mon Jun 27 14:43:13 2011
http://epydoc.sourceforge.net


Doorman
Doorman is a friendly, automated helper for managers of large online communities. Simple to install and easy to configure, Doorman can welcome new users, guide them through onboarding flows, and help keep track of important projects and events using a robust-plugin API.
Quick Start
- Fork (optional) and clone:
git clone https://github.com/FabricLabs/doorman.git
- Run
cp config/index.json.example config/index.json
& add your auth tokens - Run
npm install
- Run
npm start
Services
Doorman comes pre-configured with support for multiple chat platforms, including
Slack, Discord, and Matrix. Adding support for
additional services is easy — inspect the lib/service.js
prototype for a list
of required methods. Feel free to submit a Pull Request to add support for your
favorite services!
Plugins
Doorman behaviors range from simple triggers (commands prefixed with !
located
anywhere within a message) to complex applications which communicate
through a simple message-passing API. The trigger prefix
is configurable using the trigger
keyword in the configuration file.
Plugins are automatically loaded when included in config/index.json
, under
the "plugins"
section, or manually by calling doorman.use()
. Doorman
will look first in the ./plugins
folder for the named plugin (most useful for
simple prototyping), then will attempt to load from NPM using the doorman-*
naming pattern. Plugins may be published to the NPM registry and installed via
npm install
as usual.
Official Plugins
List of external plugins for you to include with your installation (if you wish):
- xkcd => adds the !xkcd command
- wikipedia => adds the !wiki command
- urbandictionary => adds the !urban command
- dictionary => adds the !define command
- dice => adds the !roll command
- cocktail-lookup => adds the !cocktail command
- beer-lookup => adds the !brew command
- translator => adds translation commands
- misc => adds misc commands that don't fall into other categories
- admin => adds administrative commands
- catfact => spits out a random cat fact
- insult => spits out a random PG insult
- interstellafact => spits out a random fact about Interstella 5555
- topologyfact => spits out a random topology fact
- choicemaker => makes a choice for you, based on given inputs
- 8ball => ask the magic 8ball something!
- smifffact => spits out a random fact about Will Smith
- dogfact => spits out a random dog fact
- chucknorrisfact => spits out a random fact about Chuck Norris
- mathfact => spits out a random math fact
- yearfact => spits out a random year fact
- datefact => spits out a random date fact
- remaeusfact => spits out a random fact about Remaeus
Simple Plugins
Ping-Pong Example Plugin, ./plugins/ping.json
{
"ping": "Pong!"
}
To use this plugin, add ping
to your configuration file and Doorman will
respond to any messages that include !ping
with a simple Pong!
response.
Complex Plugins
In addition to simple !triggers
, Doorman can call functions to compute
responses, or even instantiate external applications for managing long-running
processes.
Function Call Example Plugin, ./plugins/erm.js
const erm = require('erm');
const plugin = {
erm: function (msg) {
return erm(msg);
}
};
module.exports = plugin;
Instantiated Example Plugin
function MyPlugin (config) {
// config will be passed from `./config/index.json` based on the plugin name
this.start();
}
MyPlugin.prototype.start = function () {
console.log('Hello, world!');
};
module.exports = MyPlugin;
Manually Loading Plugins
To load the plugin, simply call doorman.use()
on the plugin you wish to add.
Multiple !triggers
can be added, each as key => value
mappings provided by
the plugin.
const config = require('./config');
const plugin = { fancy: 'Mmm, fancy!' };
const Doorman = require('doorman');
const doorman = new Doorman(config);
doorman.use(plugin);
doorman.start();
Message Passing API
Doorman emits events like any other EventEmitter
, using a simple router for
distinguishing between messages, users, and channels on various services. This
allows Doorman to stay connected to multiple networks simultaneously — a feature
we rely on in our flagship project, Fabric!
General Message Format
Identifiers
Doorman uses the Fabric Messaging Format to
uniquely identify objects within the system. Each object has an id
field,
which usually takes the following format:
:service/:collection/:identifier
For example, a user
event might emit the following object:
{
"id": "slack/users/U09HF4JLV",
"@data": {
"id": "U09HF4JLV"
}
}
Users (the user
event)
Channels (the channel
event)
Messages (the message
event)
State Management (the patch
event)
Configuration
Configuring Doorman will typically require the creation of a "bot" user on the platform of choice, and the use of a security token to authenticate requests.
Slack
In your team's workspace, browse to "Apps", "Custom Integrations", "Bots", and
finally "New configuration". Place the "API Token" into config/index.json
:
{
"slack": {
"token": "xoxb-0000000000000-somelongstring..."
}
}
Discord
@naterchrdsn will need to fill this out. :)
Documentation
Documentation can be generated by running npm run make:docs
— this will output
an HTML-formatted copy of the API to docs/
, which can be served with (if
installed!) http-server docs
or simply opened in your browser.


Generic class containing the asJava
converter method
Generic class containing the asJavaCollection
converter method
Generic class containing the asJavaDictionary
converter method
Generic class containing the asJavaEnumeration
converter method
Generic class containing the asScala
converter method
Test two objects for inequality.
Test two objects for inequality.
true
if !(this == that), false otherwise.
Equivalent to x.hashCode
except for boxed numeric types.
Equivalent to x.hashCode
except for boxed numeric types.
For numerics, it returns a hash value which is consistent
with value equality: if two value type instances compare
as true, then ## will produce the same hash value for each
of them.
a hash value consistent with ==
Test two objects for equality.
Test two objects for equality.
true
if the receiver object is equivalent to the argument; false
otherwise.
Cast the receiver object to be of type T0
.
Cast the receiver object to be of type T0
.
Note that the success of a cast at runtime is modulo Scala's erasure semantics.
Therefore the expression 1.asInstanceOf[String]
will throw a ClassCastException
at
runtime, while the expression List(1).asInstanceOf[List[String]]
will not.
In the latter example, because the type argument is erased as part of compilation it is
not possible to check whether the contents of the list are of the requested type.
the receiver object.
Adds an asJavaCollection
method that implicitly converts a Scala Iterable
to an immutable Java
Collection
.
Adds an asJavaCollection
method that implicitly converts a Scala Iterable
to an immutable Java
Collection
.
If the Scala Iterable
was previously obtained from an implicit or
explicit call of asSizedIterable(java.util.Collection)
then the original
Java Collection
will be returned.
The SizedIterable
to be converted.
An object with an asJava
method that returns a Java Collection
view of the argument.
Adds an asJava
method that implicitly converts a Scala mutable ConcurrentMap
to a Java ConcurrentMap
.
Adds an asJava
method that implicitly converts a Scala mutable ConcurrentMap
to a Java ConcurrentMap
.
The returned Java ConcurrentMap
is backed by the provided Scala ConcurrentMap
and any side-effects of using it via the Java interface will be visible
via the Scala interface and vice versa.
If the Scala ConcurrentMap
was previously obtained from an implicit or
explicit call of asConcurrentMap(java.util.concurrect.ConcurrentMap)
then the original
Java ConcurrentMap
will be returned.
The ConcurrentMap
to be converted.
An object with an asJava
method that returns a Java ConcurrentMap
view of the argument.
Adds an asJavaDictionary
method that implicitly converts a Scala mutable Map
to a Java Dictionary
.
Adds an asJavaDictionary
method that implicitly converts a Scala mutable Map
to a Java Dictionary
.
The returned Java Dictionary
is backed by the provided Scala
Dictionary
and any side-effects of using it via the Java interface will
be visible via the Scala interface and vice versa.
If the Scala Dictionary
was previously obtained from an implicit or
explicit call of asMap(java.util.Dictionary)
then the original
Java Dictionary
will be returned.
The Map
to be converted.
An object with an asJavaDictionary
method that returns a Java Dictionary
view of the argument.
Adds an asJavaEnumeration
method that implicitly converts a Scala Iterator
to a Java Enumeration
.
Adds an asJavaEnumeration
method that implicitly converts a Scala Iterator
to a Java Enumeration
.
The returned Java Enumeration
is backed by the provided Scala
Iterator
and any side-effects of using it via the Java interface will
be visible via the Scala interface and vice versa.
If the Scala Iterator
was previously obtained from an implicit or
explicit call of asIterator(java.util.Enumeration)
then the
original Java Enumeration
will be returned.
The Iterator
to be converted.
An object with an asJavaEnumeration
method that returns a Java Enumeration
view of the argument.
Adds an asJava
method that implicitly converts a Scala Iterable
to a Java Iterable
.
Adds an asJava
method that implicitly converts a Scala Iterable
to a Java Iterable
.
The returned Java Iterable
is backed by the provided Scala
Iterable
and any side-effects of using it via the Java interface will
be visible via the Scala interface and vice versa.
If the Scala Iterable
was previously obtained from an implicit or
explicit call of asIterable(java.lang.Iterable)
then the original
Java Iterable
will be returned.
The Iterable
to be converted.
An object with an asJavaCollection
method that returns a Java Iterable
view of the argument.
Adds an asJava
method that implicitly converts a Scala Iterator
to a Java Iterator
.
Adds an asJava
method that implicitly converts a Scala Iterator
to a Java Iterator
.
The returned Java Iterator
is backed by the provided Scala
Iterator
and any side-effects of using it via the Java interface will
be visible via the Scala interface and vice versa.
If the Scala Iterator
was previously obtained from an implicit or
explicit call of asIterator(java.util.Iterator)
then the original
Java Iterator
will be returned by the asJava
method.
The Iterator
to be converted.
An object with an asJava
method that returns a Java Iterator
view of the argument.
Adds an asScala
method that implicitly converts a Java List
to a Scala mutable Buffer
.
Adds an asScala
method that implicitly converts a Java List
to a Scala mutable Buffer
.
The returned Scala Buffer
is backed by the provided Java
List
and any side-effects of using it via the Scala interface will
be visible via the Java interface and vice versa.
If the Java List
was previously obtained from an implicit or
explicit call of asList(scala.collection.mutable.Buffer)
then the original
Scala Buffer
will be returned.
The List
to be converted.
An object with an asScala
method that returns a Scala mutable Buffer
view of the argument.
Adds an asScala
method that implicitly converts a Java ConcurrentMap
to a Scala mutable ConcurrentMap
.
Adds an asScala
method that implicitly converts a Java ConcurrentMap
to a Scala mutable ConcurrentMap
.
The returned Scala ConcurrentMap
is backed by the provided Java
ConcurrentMap
and any side-effects of using it via the Scala interface will
be visible via the Java interface and vice versa.
If the Java ConcurrentMap
was previously obtained from an implicit or
explicit call of asConcurrentMap(scala.collection.mutable.ConcurrentMap)
then the original
Scala ConcurrentMap
will be returned.
The ConcurrentMap
to be converted.
An object with an asScala
method that returns a Scala mutable ConcurrentMap
view of the argument.
Adds an asScala
method that implicitly converts a Java Iterator
to a Scala Iterator
.
Adds an asScala
method that implicitly converts a Java Iterator
to a Scala Iterator
.
The returned Scala Iterator
is backed by the provided Java
Iterator
and any side-effects of using it via the Scala interface will
be visible via the Java interface and vice versa.
If the Java Iterator
was previously obtained from an implicit or
explicit call of asIterator(scala.collection.Iterator)
then the original
Scala Iterator
will be returned.
The Iterator
to be converted.
An object with an asScala
method that returns a Scala Iterator
view of the argument.
Adds an asScala
method that implicitly converts a Java Set
to a Scala mutable Set
.
Adds an asScala
method that implicitly converts a Java Set
to a Scala mutable Set
.
The returned Scala Set
is backed by the provided Java
Set
and any side-effects of using it via the Scala interface will
be visible via the Java interface and vice versa.
If the Java Set
was previously obtained from an implicit or
explicit call of asSet(scala.collection.mutable.Set)
then the original
Scala Set
will be returned.
The Set
to be converted.
An object with an asScala
method that returns a Scala mutable Set
view of the argument.
Adds an asJava
method that implicitly converts a Scala mutable Buffer
to a Java List
.
Adds an asJava
method that implicitly converts a Scala mutable Buffer
to a Java List
.
The returned Java List
is backed by the provided Scala
Buffer
and any side-effects of using it via the Java interface will
be visible via the Scala interface and vice versa.
If the Scala Buffer
was previously obtained from an implicit or
explicit call of asBuffer(java.util.List)
then the original
Java List
will be returned.
The Buffer
to be converted.
An object with an asJava
method that returns a Java List
view of the argument.
Create a copy of the receiver object.
Adds an asScala
method that implicitly converts a Java Collection
to an Scala Iterable
.
Adds an asScala
method that implicitly converts a Java Collection
to an Scala Iterable
.
If the Java Collection
was previously obtained from an implicit or
explicit call of asCollection(scala.collection.SizedIterable)
then
the original Scala SizedIterable
will be returned.
The Collection
to be converted.
An object with an asScala
method that returns a Scala SizedIterable
view of the argument.
Adds an asScala
method that implicitly converts a Java Dictionary
to a Scala mutable Map[String, String]
.
Adds an asScala
method that implicitly converts a Java Dictionary
to a Scala mutable Map[String, String]
.
The returned Scala Map[String, String]
is backed by the provided Java
Dictionary
and any side-effects of using it via the Scala interface will
be visible via the Java interface and vice versa.
An object with an asScala
method that returns a Scala mutable Map[String, String]
view of the argument.
Adds an asScala
method that implicitly converts a Java Enumeration
to a Scala Iterator
.
Adds an asScala
method that implicitly converts a Java Enumeration
to a Scala Iterator
.
The returned Scala Iterator
is backed by the provided Java
Enumeration
and any side-effects of using it via the Scala interface will
be visible via the Java interface and vice versa.
If the Java Enumeration
was previously obtained from an implicit or
explicit call of asEnumeration(scala.collection.Iterator)
then the
original Scala Iterator
will be returned.
The Enumeration
to be converted.
An object with an asScala
method that returns a Scala Iterator
view of the argument.
Tests whether the argument (arg0
) is a reference to the receiver object (this
).
Tests whether the argument (arg0
) is a reference to the receiver object (this
).
The eq
method implements an equivalence relation on
non-null instances of AnyRef
, and has three additional properties:
x
and y
of type AnyRef
, multiple invocations of
x.eq(y)
consistently returns true
or consistently returns false
.x
of type AnyRef
, x.eq(null)
and null.eq(x)
returns false
.null.eq(null)
returns true
. When overriding the equals
or hashCode
methods, it is important to ensure that their behavior is
consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2
), they
should be equal to each other (o1 == o2
) and they should hash to the same value (o1.hashCode == o2.hashCode
).
true
if the argument is a reference to the receiver object; false
otherwise.
The equality method for reference types.
Called by the garbage collector on the receiver object when there are no more references to the object.
Called by the garbage collector on the receiver object when there are no more references to the object.
The details of when and if the finalize
method is invoked, as
well as the interaction between finalize
and non-local returns
and exceptions, are all platform dependent.
A representation that corresponds to the dynamic class of the receiver object.
A representation that corresponds to the dynamic class of the receiver object.
The nature of the representation is platform dependent.
a representation that corresponds to the dynamic class of the receiver object.
The hashCode method for reference types.
Test whether the dynamic type of the receiver object is T0
.
Test whether the dynamic type of the receiver object is T0
.
Note that the result of the test is modulo Scala's erasure semantics.
Therefore the expression 1.isInstanceOf[String]
will return false
, while the
expression List(1).isInstanceOf[List[String]]
will return true
.
In the latter example, because the type argument is erased as part of compilation it is
not possible to check whether the contents of the list are of the specified type.
true
if the receiver object is an instance of erasure of type T0
; false
otherwise.
Adds an asScala
method that implicitly converts a Java Iterable
to a Scala Iterable
.
Adds an asScala
method that implicitly converts a Java Iterable
to a Scala Iterable
.
The returned Scala Iterable
is backed by the provided Java
Iterable
and any side-effects of using it via the Scala interface will
be visible via the Java interface and vice versa.
If the Java Iterable
was previously obtained from an implicit or
explicit call of asIterable(scala.collection.Iterable)
then the original
Scala Iterable
will be returned.
The Iterable
to be converted.
An object with an asScala
method that returns a Scala Iterable
view of the argument.
Adds an asJava
method that implicitly converts a Scala Map
to a Java Map
.
Adds an asJava
method that implicitly converts a Scala Map
to a Java Map
.
The returned Java Map
is backed by the provided Scala
Map
and any side-effects of using it via the Java interface will
be visible via the Scala interface and vice versa.
If the Scala Map
was previously obtained from an implicit or
explicit call of asMap(java.util.Map)
then the original
Java Map
will be returned.
The Map
to be converted.
An object with an asJava
method that returns a Java Map
view of the argument.
Adds an asScala
method that implicitly converts a Java Map
to a Scala mutable Map
.
Adds an asScala
method that implicitly converts a Java Map
to a Scala mutable Map
.
The returned Scala Map
is backed by the provided Java
Map
and any side-effects of using it via the Scala interface will
be visible via the Java interface and vice versa.
If the Java Map
was previously obtained from an implicit or
explicit call of asMap(scala.collection.mutable.Map)
then the original
Scala Map
will be returned.
The Map
to be converted.
An object with an asScala
method that returns a Scala mutable Map
view of the argument.
Adds an asJava
method that implicitly converts a Scala mutable Map
to a Java Map
.
Adds an asJava
method that implicitly converts a Scala mutable Map
to a Java Map
.
The returned Java Map
is backed by the provided Scala
Map
and any side-effects of using it via the Java interface will
be visible via the Scala interface and vice versa.
If the Scala Map
was previously obtained from an implicit or
explicit call of asMap(java.util.Map)
then the original
Java Map
will be returned.
The Map
to be converted.
An object with an asJava
method that returns a Java Map
view of the argument.
Adds an asJava
method that implicitly converts a Scala mutable Seq
to a Java List
.
Adds an asJava
method that implicitly converts a Scala mutable Seq
to a Java List
.
The returned Java List
is backed by the provided Scala
Seq
and any side-effects of using it via the Java interface will
be visible via the Scala interface and vice versa.
If the Scala Seq
was previously obtained from an implicit or
explicit call of asSeq(java.util.List)
then the original
Java List
will be returned.
The Seq
to be converted.
An object with an asJava
method that returns a Java List
view of the argument.
Adds an asJava
method that implicitly converts a Scala mutable Set
to a Java Set
.
Adds an asJava
method that implicitly converts a Scala mutable Set
to a Java Set
.
The returned Java Set
is backed by the provided Scala
Set
and any side-effects of using it via the Java interface will
be visible via the Scala interface and vice versa.
If the Scala Set
was previously obtained from an implicit or
explicit call of asSet(java.util.Set)
then the original
Java Set
will be returned.
The Set
to be converted.
An object with an asJava
method that returns a Java Set
view of the argument.
Equivalent to !(this eq that)
.
Equivalent to !(this eq that)
.
true
if the argument is not a reference to the receiver object; false
otherwise.
Wakes up a single thread that is waiting on the receiver object's monitor.
Wakes up a single thread that is waiting on the receiver object's monitor.
Wakes up all threads that are waiting on the receiver object's monitor.
Wakes up all threads that are waiting on the receiver object's monitor.
Adds an asScala
method that implicitly converts a Java Properties
to a Scala mutable Map[String, String]
.
Adds an asScala
method that implicitly converts a Java Properties
to a Scala mutable Map[String, String]
.
The returned Scala Map[String, String]
is backed by the provided Java
Properties
and any side-effects of using it via the Scala interface will
be visible via the Java interface and vice versa.
An object with an asScala
method that returns a Scala mutable Map[String, String]
view of the argument.
Adds an asJava
method that implicitly converts a Scala Seq
to a Java List
.
Adds an asJava
method that implicitly converts a Scala Seq
to a Java List
.
The returned Java List
is backed by the provided Scala
Seq
and any side-effects of using it via the Java interface will
be visible via the Scala interface and vice versa.
If the Scala Seq
was previously obtained from an implicit or
explicit call of asSeq(java.util.List)
then the original
Java List
will be returned.
The Seq
to be converted.
An object with an asJava
method that returns a Java List
view of the argument.
Adds an asJava
method that implicitly converts a Scala Set
to a Java Set
.
Adds an asJava
method that implicitly converts a Scala Set
to a Java Set
.
The returned Java Set
is backed by the provided Scala
Set
and any side-effects of using it via the Java interface will
be visible via the Scala interface and vice versa.
If the Scala Set
was previously obtained from an implicit or
explicit call of asSet(java.util.Set)
then the original
Java Set
will be returned.
The Set
to be converted.
An object with an asJava
method that returns a Java Set
view of the argument.
Creates a String representation of this object.
Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.
a String representation of the object.

The following conversions also are supported, but the direction Scala to Java is done my a more specifically named method:
asJavaCollection
,asJavaEnumeration
,asJavaDictionary
.scala.collection.Iterable
<=>java.util.Collection
scala.collection.Iterator
<=>java.util.Enumeration
scala.collection.mutable.Map
<=>java.util.Dictionary
In addition, the following one way conversions are provided via
asJava
:scala.collection.Seq =>
java.util.List }
-scala.collection.mutable.Seq =>
java.util.List
-scala.collection.Set
=>java.util.Set
-scala.collection.Map
=>java.util.Map
2.8.1


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ eye WEEKLY May 5 1994 Toronto's arts newspaper ...free every Thursday ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ FILM FILM
WHEN A MAN LOVES A WOMAN Starring Meg Ryan and Andy Garcia. Screenplay by Ronald Bass and Al Franken. Directed by Luis Mandoki. (STC) Opens May 6. by Gary Michael Dault
WHEN A MAN LOVES A WOMAN is a good-hearted movie about alcoholism and it really wants, I think, to help, to understand, to offer hope. What it succeeds in doing, however, is to pretty up the problem to the point where it's all just matter of mutual adjustment, really. No big deal. This does alcoholism a disservice. And the audience, too.
Meg Ryan--who has the cutest gums in cinema--is Alice Green ("Hi, Alice!") and she's been an alcoholic for a long time. She has somehow managed to keep her problem from her extraordinarily loving husband, Michael (Andy Garcia--who has one of the most penetratingly loving gazes in cinema), for so long that it's a little hard to believe that Alice's squirreling away of litres of vodka in every nook and cranny of their well-appointed home is going unnoticed (she admits she's up to a quart a day).
Well, the children (two adorable little girls) notice, actually, and they end up finally making Mommy's difficulties clear to Daddy. Mom is behaving oddly, like one day falling through the glass shower door and lying there naked on the broken glass, looking dead.
Alice and Michael are way too good to be true. They smile way too much. The film feels liberal and enlightened because it proposes, quite correctly, that Alice's alcoholism is not her fault. What she gets instead of blame is endless empathy from Michael--so much self-sacrifice, so much spaniel-eyed support that you begin to long for a scene or two where one of them acts real. Alcoholism is whitewashed into some marital glitch, most of the problem being, apparently, that the doting Michael's paternalistic care for his wife makes her feel small and inept.
The script, by writer/executive producer Ronald Bass and writer/executive producer Al Franken, manages to be witty and smarmy all at the same time--no small feat, but one you might reasonably expect from Bass, who pens weepers like RAIN MAN and THE JOY LUCK CLUB, and from "Saturday Night Live" alumnus Al Franken, who obviously possesses more than just a hint of his own creation, the new-age cable TV host whose book I'M GOOD ENOUGH, I'M SMART ENOUGH, AND DOGGONE IT, PEOPLE LIKE ME: DAILY AFFIRMATIONS WITH STUART SMALLEY is a bestseller. The film is adequately directed by Luis Mandoki, whose Born Yesterday and White Palace have not kicked the envelope of contemporary cinema. It's also about 35 minutes too long.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Freely transmitable in cyberspace Author holds traditional copyright<EMAIL_ADDRESS>(416-971-8421) Archives: ftp/gopher io.org /pub/eye.WEEKLY
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Yayoi Kusama 'Every Day I Pray For Love' exhibit(10 images) Visitors viewed Yayoi Kusama's "Every Day I Pray For Love" exhibit November 15, 2019, at the David Zwirner gallery in New York City. 16 Nov 2019, 17:02 People stand inside "Infinity Mirrored Room - Dancing Lights That Flew Up to the Universe" as part of the exhibition of entirely new work by Yayoi Kusama. Photo by John Angelillo/UPI | License Photo The exhibit "Every Day I Pray For Love" runs through December 14, 2019. Photo by John Angelillo/UPI | License Photo "Ladder to Heaven" Photo by John Angelillo/UPI | License Photo The exhibit opened November 9, 2019. Photo by John Angelillo/UPI | License Photo Many of Yayoi Kusama's artworks make use of repeated dots. Photo by John Angelillo/UPI | License Photo The exhibit includes a number of paintings from the artist's "My Eternal Soul" series. Photo by John Angelillo/UPI | License Photo The exhibit includes paintings, sculptures and installations. Photo by John Angelillo/UPI | License Photo Kusama's infinity room sculptures make use of mirrors and light to created repeated patterns. Photo by John Angelillo/UPI | License Photo People wait to enter the infinity room. Photo by John Angelillo/UPI | License Photo A floor installation includes nearly 100 stainless-steel elements. Photo by John Angelillo/UPI | License Photo


Select two Starships from the dropdown lists to compar
CR90 Corvette
V-wing
Belbullab-22 Starfighter
Jedi Interceptor
Star Destroyer
Trade Fedaration Cruiser
Solar Sailer
Republic Attack Cruiser
A-wing
B-wing
Naboo Fighter
Millenium Falcon
CR90 Corvette
V-wing
Belbullab-22 Starfighter
Jedi Interceptor
Star Destroyer
Trade Fedaration Cruiser
Solar Sailer
Republic Attack Cruiser
A-wing
B-wing
Naboo Fighter
Millenium Falcon
compare
Starship 1
Starship 2
Name
Cost
Speed
Cargo Size
Passengers


Markov logic: Questions
- Consider a statement like Moral(x) \(\implies\) Happy(x). Consider 2 worlds: one where most people are moral, and all but 5 moral people are happy, another where only 5 people are moral, and they are all unhappy. It seems in the Markov model they would have the same weight, when the statement is represented as \(\neg\text{Moral}(x) \wedge \text{Happy}(x)\). Do we want this? I’m guessing this is easier than only restricting to moral people, because that involves dividing.
- I don’t understand the terminology used in LazySAT. My understanding of
active_atoms
is that we take every clause that is not satisfied and add ALL of its atoms. (Ex. if we have a formula \(Friend(A,B)\implies Happy(A) \wedge Happy(B)\), and \(\text{Friend}(x,y) \wedge \neg \text{Happy}(x)\wedge \text{Happy}(y)\), then both \(x,y\) are considered active atoms.)
- But then choosing unsatisfied \(x\) and \(v_f\sim c\), it’salways true that \(v\in\) active atoms, whereas in Algorithm 2, they consider when \(v\nin\) active atoms!
- Note DeltaCost can be easily calculated. Local flipping doesn’t require recalculation of the whole cost.
- Shouldn’t DeltaCost be a function of a setting of variables, not a variable? Or is it like the derivative in the direction of variable \(v\), i.e., what you’d get by flipping \(v\)? But you may need to flip two variables in a clause at the same time to get something better!
- I don’t understand the explanation on p. 8: The initial active atoms are all those appearing in clauses that are unsatisfied if only the atoms in the database are true, and all others are false.
- More fundamentally, I don’t understand what the database is!
- At each step, take a random unsatisfied clause. Maintain a set of active atoms.
- With probability \(p\) choose a random variable from the clause.
- Otherwise, choose the non-active variable \(v\) in \(c\) is lowest DeltaCost. (Why do we ignore active atoms? Isn’t it true that flipping them can also decrease the cost?)
- Add the chosen variable \(v_f\) to
active_atoms
and add activated clauses. Flip \(v_f\).
- (Do we not want variables to be flipped twice?)
- NO: we choose the variable (active OR non-acive) in \(c\) with lowest DeltaCost. It’s merely saying that we have to do a more involved computation if the variable is non-active. (Why? This has something to do with the DB vs. KB, no comprendo.)
- At the beginning, only include active atoms/clauses. Think of these as the dangerous atoms—flipping them could make a clause not satisfied. These clauses are the only clauses we will need to worry about. Add clauses to the active set only if we need to worry about them.
- So what’s the difference between SAT and LazySAT? I think it’s just: are you summing over all possible instantiations (unnecessary!), or just looking at the differences when you flip a variable? You can ignore formulas that don’t invove the current variable.
(OK to have some kind of “complexity measure” of formulae saying how amenable they are to random-walk methods?)
- Intuition about deterministic vs. non-deterministic dependencies. (Tradeoff between search and following stochasticity cf. gradient? The smaller the weights the easier the flow but the lower the probability is to find a satisfying instance?)
- MC-SAT has hard satisfiability. Look at all clauses satisfied in the last step; the larger the weight, the more likely you are to force it to be satisfied next step. It calls on a uniform SAT solver (which doesn’t really exist—but there are things that do well in practice).
- p. 12. Indistinguishable objects. What if you’re just strying to find a distribution that’s close, ex. for at most binary relations, look at the proportion of \(\{a,b\}\) with values of \(u_1(a),\ldots, u_1(b),\ldots, b_1(a,b),\ldots\) where \(u\) are unary and \(b\) are binary relations.
Perhaps I need to learn about databases.
- What is the closed-world assumption?
Wait, you aren’t flipping nodes! I thought of the nodes as the actors, and unary functions on them. But are the nodes supposed to be formulae? Like \(u_1(x)\), \(b_1(x,y)\), and everything not in it is false?
An atom is not a node but predicates applied to nodes!
(Note the logical contradictions is not on the level of node values, but on the formulas relating them? Don’t have \(A\wedge B\) as nodes, only have \(A\), \(B\).) Atoms are formulas without connectives like \(\wedge, \implies,\forall...\)
basic inference problem in first-order logic is to determine whether a knowledge base KB entails a formula F, i.e., if F is true in all worlds where KB is true
Sparsity in the sense that only the relations in the database can be true; everything else has to be false?
Also, I don’t understand how to deal with intermediate functions like \(f(x,g(y))\). It seems there’s too many possible values of \(g\)!
Approaches to get past intractability:
- The pseudo-likelihood is \(\ln \Pj_w^*(X=x) = \sumo ln \log \Pj_w(X_l=x_l|MB_x(X_l))\) (markov blanket). (When is this a good approx?)
- Discriminative weight learning. Partition into evidence and query atoms and calculate conditional log-likelihood. (cf. RBM)
- Inductive logic programming #lookup. But use evaluation function based on pseudo-likelihood rather than accuracy and coverage.
19 Dependencies are really probabilistic. Ex. two titles sharing a word are more likely to be the same?
Applications.
- Entity resolution (when do things refer to the same object? Include formulae like transitivity of equality.)
- Citation resolution. (Ex. which article corresponds to which citation, when are they the same? You can imagine there’s some general rules which would do well.)
Lifted inference, lifted resolution in FOL #lookup
[KSJ] A general stochastic approach to solving problems with hard and soft constraints
- My understanding of “partitioning”: solve a problem hierarchically: break into smaller pieces, find a list of good solutions of each piece, and then figure out how to combine those solutions.
- Q: is there an algorithm agnostic to the encoding in some sense? (Doubtful—probably can embed crypto problems? But what if you only allow the simplest transformations?)
- WalkSAT does only flip one variable at a time.
- Hard constraints have greater weight than soft constraints.
I think people do MCMC in problem-solving. Try to tweak things locally. Sometimes though there’s a larger restructuring—view it as a step in a more abstract space, a more abstract transformation?
Scraps
(Patterns you construct are patterns you could have found?)
Goal in learning should be to find the formula with weights which decrease the entropy the most?
SAT refutations corresponding to reasonable mathematical statements have short proofs but not the SAT framework? (Any way to compile down?)
Directions
- First, understand the classical results on learning and inference in graphical models.
- Understand MCMC and variational inference, and the situations where they have provable guarantees.
- Try to formulate the simplest problem where you do have some element of first-order logic (ex. a statement with \(\forall\)) and/or some combinatorial complexity.
- What’s a test problem in this domain? They give citation resolution. Maybe this is practical but it seems like a rather boring problem!
- Understand some ideas from the logic-learning community (inductive logic programming, etc.) ILP. Machine learning \(\cap\) programming languages???


--- layout: post status: publish published: true title: Generic Programming author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 993 wordpress_url: http://winterdom.com/2002/11/genericprogramming date: '2002-11-15 18:20:48 +0000' date_gmt: '2002-11-15 18:20:48 +0000' categories: - ".NET" tags: [] comments: [] ---
Sam continues posting good stuff on Generic Programming. Love it when he gets on a roll :)


A result of IAM Policy search, containing information of an IAM policy.
Inheritance
Implements
Inherited Members
Namespace: Google.Cloud.Asset.V1
Assembly: Google.Cloud.Asset.V1.dll
Syntax
public sealed class IamPolicySearchResult : IMessage<IamPolicySearchResult>, IMessage, IEquatable<IamPolicySearchResult>, IDeepCloneable<IamPolicySearchResult>
Constructors
IamPolicySearchResult()
Declaration
public IamPolicySearchResult()
IamPolicySearchResult(IamPolicySearchResult)
Declaration
public IamPolicySearchResult(IamPolicySearchResult other)
Parameters
| Type | Name | Description |
|---|---|---|
| IamPolicySearchResult | other |
Properties
Explanation
Explanation about the IAM policy search result. It contains additional information to explain why the search result matches the query.
Declaration
public IamPolicySearchResult.Types.Explanation Explanation { get; set; }
Property Value
| Type | Description |
|---|---|
| IamPolicySearchResult.Types.Explanation |
Policy
The IAM policy directly set on the given resource. Note that the original IAM policy can contain multiple bindings. This only contains the bindings that match the given query. For queries that don't contain a constrain on policies (e.g., an empty query), this contains all the bindings.
To search against the policy
bindings:
- use a field query:
- query by the policy contained members. Example:
<EMAIL_ADDRESS>- query by the policy contained roles. Example:
policy:roles/compute.admin
- query by the policy contained roles' included permissions. Example:
policy.role.permissions:compute.instances.create
Declaration
public Policy Policy { get; set; }
Property Value
| Type | Description |
|---|---|
| Google.Cloud.Iam.V1.Policy |
Project
The project that the associated GCP resource belongs to, in the form of projects/{PROJECT_NUMBER}. If an IAM policy is set on a resource (like VM instance, Cloud Storage bucket), the project field will indicate the project that contains the resource. If an IAM policy is set on a folder or orgnization, the project field will be empty.
To search against the project
:
- specify the
scope
field as this project in your search request.
Declaration
public string Project { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
Resource
The full resource name of the resource associated with this IAM policy.
Example:
//compute.googleapis.com/projects/my_project_123/zones/zone1/instances/instance1
.
See Cloud Asset Inventory Resource Name
Format
for more information.
To search against the resource
:
- use a field query. Example:
resource:organizations/123
Declaration
public string Resource { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |


Control which websites are listed in the RootsSearch popup. Email us to suggest other genealogy websites that can be added to this list.


Click the button without entering information:
value:
{{demoCtrl.member | json}}
required
required, number
required, email
password
retype password
Inline edit
{{demoCtrl.member.comment}}
Reference data
alert() will be called only if validation is passed: action should be confirmed too:
Save
{{ 'authenticate.login.header.forgotPassword' | translate }}
if empty string - value will be undefined:
undefined if empty: {{demoCtrl.undefinedifempty | json}}
Form is autosaved everytime it is changed - see network activity
Favourite color
Favourite pet


Contacts
Contacts name
Phone number
Email address
Company name
Last contacted
William Smith
555-642-7371
<EMAIL_ADDRESS>ACME industries
2014-10-21
Bob Morris
555-999-2991
<EMAIL_ADDRESS>ABC Corp
2014-09-12
2 contacts loaded
Sales Leads


--- layout: default nav: tutorial ---
This tutorial will show you how to implement bulk operations on a table using IntercoolerJS.
Here are the steps for implementing bulk operations
ic-src
attribute to
re-render the table. Give the form a useful ID.
ic-post-to
attribute, and include the
checked rows by using the ic-post-to
.
Here is a diff showing what's necessary to implement the bulk operations:
https://github.com/LeadDyno/intercooler-tutorial-app/commit/0f3499cdf8896180fa50fe9dac48a88315d82256


|
Drake
|
Helper class to convert a System into a System<T>, intended for internal use by the System framework, not directly by users.
For user-facing documentation see System Scalar Conversion.
Because it is not templated on a System subclass, this class can be used by LeafSystem without any direct knowledge of the subtypes being converted. In other words, it enables a runtime flavor of the CRTP.
Throughout this class, the template type S
must be the most-derived concrete System subclass. This object may only be used to convert System objects of runtime type S, not subclasses of S.
#include <drake/systems/framework/system_scalar_converter.h>
Public Types | |
| enum | GuaranteedSubtypePreservation { kEnabled, kDisabled } |
| A configuration option for our constructor, controlling whether or not the Convert implementation requires that the System subclass type is preserved. More... | |
| template<typename T , typename U > | |
| using | ConverterFunction = std::function< std::unique_ptr< System< T > >(const System< U > &)> |
| A std::function used to convert a System into a System<T>. More... | |
Public Member Functions | |
| SystemScalarConverter () | |
| Creates an object that returns nullptr for all Convert() requests. More... | |
| template<template< typename > class S> | |
| SystemScalarConverter (SystemTypeTag< S > tag) | |
| Creates an object that uses S's scalar-type converting copy constructor. More... | |
| template<template< typename > class S> | |
| SystemScalarConverter (SystemTypeTag< S >, GuaranteedSubtypePreservation subtype_preservation) | |
| (Advanced) Creates using S's scalar-type converting copy constructor. More... | |
| bool | empty () const |
| Returns true iff no conversions are supported. More... | |
| template<typename T , typename U > | |
| void | Add (const ConverterFunction< T, U > &) |
| Registers the std::function to be used to convert a System into a System<T>. More... | |
| template<template< typename > class S, typename T , typename U > | |
| void | AddIfSupported () |
| Adds converter for an S into an S<T>, iff scalar_conversion::Traits says its supported. More... | |
| void | RemoveUnlessAlsoSupportedBy (const SystemScalarConverter &other) |
Removes from this converter all pairs where other.IsConvertible<T, U> is false. More... | |
| template<typename T , typename U > | |
| bool | IsConvertible () const |
| Returns true iff this object can convert a System into a System<T>, i.e., whether Convert() will return non-null. More... | |
| template<typename T , typename U > | |
| std::unique_ptr< System< T > > | Convert (const System< U > &other) const |
| Converts a System into a System<T>. More... | |
Implements CopyConstructible, CopyAssignable, MoveConstructible, MoveAssignable | |
| SystemScalarConverter (const SystemScalarConverter &)=default | |
| SystemScalarConverter & | operator= (const SystemScalarConverter &)=default |
| SystemScalarConverter (SystemScalarConverter &&)=default | |
| SystemScalarConverter & | operator= (SystemScalarConverter &&)=default |
| using ConverterFunction = std::function<std::unique_ptr<System<T> >(const System<U>&)> |
A std::function used to convert a System into a System<T>.
|
strong |
A configuration option for our constructor, controlling whether or not the Convert implementation requires that the System subclass type is preserved.
| Enumerator | |
|---|---|
| kEnabled | The argument to Convert must be of the exact type S that was used to populate the SystemScalarConverter. |
| kDisabled | The argument to Convert need not be the exact type S that was used to populate the SystemScalarConverter – it can be either exactly that S, or a subtype of that S. This permits subtype information to be lost across conversion. |
|
default |
|
default |
Creates an object that returns nullptr for all Convert() requests.
The single-argument constructor below is the typical way to create a useful instance of this type.
| SystemScalarConverter | ( | SystemTypeTag< S > | tag | ) |
Creates an object that uses S's scalar-type converting copy constructor.
That constructor takes the form of, e.g.:
This constructor only creates a converter between a limited set of types, specifically the default scalars.
By default, all non-identity pairs (pairs where T and U differ) drawn from the above list can be used for T and U. Systems may specialize scalar_conversion::Traits to disable support for some or all of these conversions, or after construction may call Add<T, U>() on the returned object to enable support for additional custom types.
| S | is the System type to convert |
This an implicit conversion constructor (not marked explicit
), in order to make calling code substantially more readable, with relatively little risk of an unwanted accidental conversion happening.
See System Scalar Conversion for additional overview documentation.
| SystemScalarConverter | ( | SystemTypeTag< S > | , |
| GuaranteedSubtypePreservation | subtype_preservation | ||
| ) |
(Advanced) Creates using S's scalar-type converting copy constructor.
Behaves exactly like SystemScalarConverter(SystemTypeTag<S>), but with the additional option to turn off guaranteed subtype preservation of the System being converted. In general, subtype preservation is an important invariant during scalar conversion, so be cautious about disabling it.
| void Add | ( | const ConverterFunction< T, U > & | ) |
Registers the std::function to be used to convert a System into a System<T>.
A pair of types can be registered (added) at most once.
| void AddIfSupported | ( | ) |
Adds converter for an S into an S<T>, iff scalar_conversion::Traits says its supported.
The converter uses S's scalar-type converting copy constructor.
Converts a System into a System<T>.
This is the API that LeafSystem uses to provide a default implementation of DoToAutoDiffXd, etc.
| U | the donor scalar type (to convert from) |
| T | the resulting scalar type (to convert into) |
| bool empty | ( | ) | const |
Returns true iff no conversions are supported.
(In other words, whether this is a default-constructed object.)
| bool IsConvertible | ( | ) | const |
|
default |
|
default |
| void RemoveUnlessAlsoSupportedBy | ( | const SystemScalarConverter & | other | ) |
Removes from this converter all pairs where other.IsConvertible<T, U>
is false.
The subtype S
need not be the same between this and other
.


gulp_place("app.name", "variable") — Examples
⇠ Go back to GitHub repositoryGlobal options
Following demonstrates alias settings, it is also possible use removeAlias
and changeOptions
. Changes doesn’t affect already generated icons and the last one isn't testable for style
options (library doesn’t supprot dynamic change).
--svg-icon-size
and color
in case your svg icon has setted fill: currentColor
.",
example: "simpleWithStyling"
}', "eval")
gulp_place("./templates/xmp_example.sub.html", "file")
gulp_place('__test_build__= {
headline: "More styling example",
description: "<svg-icon>
is by default block element with `width/height` setted to var(--svg-icon-size, 1em)
",
example: "styling"
}', "eval")
gulp_place("./templates/xmp_example.sub.html", "file")
gulp_place('__test_build__= {
headline: "SVG with multiple colors via CSS vars",
description: "This icon has setted colors with: var(--announcements-color1, red)
and var(--announcements-color2, currentColor)
.",
example: "multipleColors"
}', "eval")
gulp_place("./templates/xmp_example.sub.html", "file")


Package Model
Class Model
- java.lang.Object
-
- Model.Model
-
public class Model extends java.lang.Object
Model class serves as main model of the app
-
-
Constructor Summary
Constructors Constructor Description Model()
Default class Constructor
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description java.util.LinkedList<Ranking>
actual5()
get the stats of the current servicevoid
addDishToReserve(User client, Dish dish)
adding dish to bbddvoid
addReserve(int id, Reserve client)
add a reserve into the tablevoid
addReserve(Reserve client)
adds a reserve to the listvoid
callCommand(java.lang.String command, java.lang.Object obj)
function that takes a comannd an based of that treats a objectvoid
closeService()
close serviceint
getCommuncicationPort()
getter communication Portjava.util.LinkedList<Dish>
getDishes()
getter of list of dishesjava.util.LinkedList<Menu>
getMenus()
getter of list of MenusRestaurant
getOnService()
getter of the current restaurantReserve
getReserveFromReserveName(java.lang.String reserveName)
getter of reserve from a reserve nameReserve
getReserveFromUser(User u)
getter reserve from userReserve
getReserveNamed(java.lang.String nameReseve)
getter of reserve based on a reserve namejava.util.LinkedList<Reserve>
getReserves()
getter of list of reservesint
getReserveTableId(Reserve r)
getter of the table id from reservejava.lang.String
getServerState()
getter of the server statejava.util.LinkedList<Table>
getTables()
getter of list of tablesboolean
isReservedForNow(java.lang.String nameReseve)
getter of boolean that tells if is a reserve now or notint
numeberOfReserves()
getter of number of reserves madevoid
removeReserveTable(Reserve var)
remove a table reservedvoid
setReserves(java.util.LinkedList<Reserve> reserves)
setter of the reserves listvoid
setServerState(java.lang.String state)
setter of the string of server statejava.util.LinkedList<Ranking>
top5()
get the stats
-
-
-
Method Detail
-
setServerState
public void setServerState(java.lang.String state)
setter of the string of server state- Parameters:
state
- string of the server state
-
callCommand
public void callCommand(java.lang.String command, java.lang.Object obj)
function that takes a comannd an based of that treats a object- Parameters:
command
- string that takes an orderobj
- to treat
-
numeberOfReserves
public int numeberOfReserves()
getter of number of reserves made- Returns:
- number of reserves
-
getDishes
public java.util.LinkedList<Dish> getDishes()
getter of list of dishes- Returns:
- list of dishes
-
getTables
public java.util.LinkedList<Table> getTables()
getter of list of tables- Returns:
- list of tables
-
getReserves
public java.util.LinkedList<Reserve> getReserves()
getter of list of reserves- Returns:
- list of reserves
-
getMenus
public java.util.LinkedList<Menu> getMenus()
getter of list of Menus- Returns:
- list of menus
-
removeReserveTable
public void removeReserveTable(Reserve var)
remove a table reserved- Parameters:
var
- Reserve to remove
-
isReservedForNow
public boolean isReservedForNow(java.lang.String nameReseve)
getter of boolean that tells if is a reserve now or not- Parameters:
nameReseve
- name of reserve- Returns:
- true in case is a reserve
-
addReserve
public void addReserve(Reserve client)
adds a reserve to the list- Parameters:
client
- to add
-
addReserve
public void addReserve(int id, Reserve client)
add a reserve into the table- Parameters:
id
- of taleclient
- to add
-
getReserveNamed
public Reserve getReserveNamed(java.lang.String nameReseve)
getter of reserve based on a reserve name- Parameters:
nameReseve
- name of reserve- Returns:
- a reserve
-
getReserveFromUser
public Reserve getReserveFromUser(User u)
getter reserve from user- Parameters:
u
- user- Returns:
- reserve
-
getServerState
public java.lang.String getServerState()
getter of the server state- Returns:
- a string that represents the server state
-
getCommuncicationPort
public int getCommuncicationPort()
getter communication Port- Returns:
- integer of port
-
getOnService
public Restaurant getOnService()
getter of the current restaurant- Returns:
- current restaurant
-
addDishToReserve
public void addDishToReserve(User client, Dish dish)
adding dish to bbdd- Parameters:
client
- to add to the bbdddish
- to add to the bbdd
-
getReserveTableId
public int getReserveTableId(Reserve r)
getter of the table id from reserve- Parameters:
r
- reserve- Returns:
- table id
-
getReserveFromReserveName
public Reserve getReserveFromReserveName(java.lang.String reserveName)
getter of reserve from a reserve name- Parameters:
reserveName
- string of reserve name- Returns:
- reserve asossociated with param
-
setReserves
public void setReserves(java.util.LinkedList<Reserve> reserves)
setter of the reserves list- Parameters:
reserves
- list of reserves
-
top5
public java.util.LinkedList<Ranking> top5()
get the stats- Returns:
- the stats
-
actual5
public java.util.LinkedList<Ranking> actual5()
get the stats of the current service- Returns:
- stats of the current service
-
closeService
public void closeService()
close service
-
-


*****Click "See my details" to see the data PRPSFL holds on you*****
Jane Doe
<EMAIL_ADDRESS>Phone
Communication Preference
**** *** ****
*****
To update any of your details or request for your account to be deleted and your details removed from our database, email social@prpsfl.com


SFU
Security Request Rejected
Greeting
Your request (ID trackingID) has been rejected.
Reason:
rejectionMessage


There are many variations of passages of Lorem Ipsum typesetting industry.
There are many variations of passages of Lorem Ipsum typesetting industry. Lorem Ipsum has been the industry's standard.There are many variations of passages of Lorem Ipsum typesetting industry. Lorem Ipsum has been the industry's standard.
LThere are many variations of passages of Lorem Ipsum typesetting industry. Lorem Ipsum has been the industry's standard.
There are many variations of passages of Lorem Ipsum typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
There are many variations of passages of Lorem Ipsum typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
There are many variations of passages of Lorem Ipsum typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
There are many variations of passages of Lorem Ipsum typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.There are many variations of passages of Lorem Ipsum typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.There are many variations of passages of Lorem Ipsum typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.There are many variations of passages of Lorem Ipsum typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.


{% extends "views/platform-admin/_base_template.html" %} {% from "components/big-number.html" import big_number_simple %} {% from "components/status-box.html" import status_box %} {% from "components/form.html" import form_wrapper %} {% from "govuk_frontend_jinja/components/details/macro.html" import govukDetails %} {% from "govuk_frontend_jinja/components/button/macro.html" import govukButton %} {% block per_page_title %} Summary {% endblock %} {% block platform_admin_content %}


{% extends "base.html" %} {% block head %} {{ super() }} {% endblock %} {% block content %} {% if success %}
Thank you for your message. We'll get back to you shortly.


# Markdown in the light dom
[A link! (not Link from Zelda)](https://access.redhat.com)
This is pretty easy too. You just need to worry about indentation.
Updating the pfe-markdown tag dynamically
Updating the pfe-markdown tag dynamically (a second time)
Changing the light dom to show that pfe-markdown updates the markdown


Trashy Tips
About
Trashy tips helps people turn their trash into treasure by providing maps, guides, and information on all sorts of garbage.
Maps
Looking for places to drop off your trash? Check the maps for locations where you can donate or recycle old clothing, electronics and more!
Recyclers
TerraCycle can collect and recycle almost any form of waste and diverts millions of pounds of waste from landfills and incinerators each month.
Best Buy will take all kinds of used tech, no matter where you bought it or how old it is.
When it's time to upgrade your laptops, printers and other hardware or replace your ink and toner, count on Staples to recycle it responsibly - and make it easy.
Your donationed items are sold at their Family Stores. The proceeds are used to fund Adult Rehabilitation Centers, where those in the grip of addiction find help, hope, and a second chance at life.
Housing Works is a healing community of people living with and affected by HIV/AIDS. Our mission is to end the dual crises of homelessness and AIDS through relentless advocacy, the provision of lifesaving services, and entrepreneurial businesses that sustain our efforts.
Goodwill works to enhance the dignity and quality of life of individuals and families by strengthening communities, eliminating barriers to opportunity, and helping people in need reach their full potential through learning and the power of work.
North America's largest, most reliable battery recycling program.
Curbside bins for reusing/recycling clothing and textiles.


Building on The Firm Foundation of Our Historic Legacy
Most Worshipful Prince Hall Grand Lodge of Ohio Free & Accepted Masons
Amaranth Grand Chapter OES
Follow Sidonia No. 93


Address
Administrator
AuthenticationManager
Comment
Customer
DriversLicense
LocationAdminManager
MembershipManager
PaymentInfo
PaymentManager
RentalLocation
Reservation
ReservationManager
SendEmail
SystemContext
User
UserAdminManager
UserManager
Vehicle
VehicleAdminManager
VehicleType
YouDriveDAO
|


First page
Back
Continue
Last page
Overview
Graphics
Communication
Arduino
More PWM channels (6 vs 1)
Servo library (motor control)
Real time
Other devices
GPS
Accelerometers


Working on It
1 Minute Read 37 WordsComing Soon I swear, we’re working on it. This is us We all had to start out, once; we need to remain empathetic and kind to those who come after us. Luke Rebarchik Tyler Winzenried Camilla Coronado
I swear, we're working on it.
Coming Soon I swear, we’re working on it. This is us We all had to start out, once; we need to remain empathetic and kind to those who come after us. Luke Rebarchik Tyler Winzenried Camilla Coronado
Coming Soon I swear, we’re working on it. This is us We all had to start out, once; we need to remain empathetic and kind to those who come after us. Luke Rebarchik Tyler Winzenried Camilla Coronado
Read more →


This template adds the necessary equates and libraries to your application to enable you to utilize the Screen Capture Tools API calls. The template also adds code to the First Procedure (as specified in the Application Properties dialog) to initialize the Screen Capture Tools Library.
Generate template globals as EXTERNAL
Adds the EXTERNAL attribute to the global variable declarations generated by the templates. This means your program relies on an external library to allocate memory for these variables, and to export them so your program can access them.
The templates do not currently generate any global variable declarations. This option is reserved for future use.
External Globals and ABCs Source Module
Specify whether the external library is dynamically or statically linked.
This sets the flag parameter of the DLL attribute for template generated class declarations. See the Language Reference for more information on the DLL attribute.
This template generates code similar to the following:
SCT_Init(AppFrame{PROP:Handle},AppFrame{PROP:ClientHandle},SYSTEM{PROP:AppInstance})
See Also: SCT_Init Procedure


--- layout: page title: "About" description: "Something about me" header-img: "img/about-bg.jpg" ---
Hi there! My name is Tuan Anh Le, just call me Andy for short
Currently, I'm keen on researching and building products related to Prediction/Recommendation. Extracts meaning from noisy data and discover patterns in randomly data, then use this information to understand the market, competition trends and user needs... Playing with Akka/Scala is also one of my interests.


Why Use Postgres (Updated for Last 5 Years)
Five years ago I wrote a post that got some good attention on why you should use Postgres. Almost a year later I added a bunch of things I missed. Many of those items bear repeating, and I’ll recap a few of those in the latter half of this post. But in the last 4-5 years there’s been a lot of improvements and more reasons added to the list of why you should use Postgres. Here’s the rundown of the things that make Postgres a great database you should consider using.
Datatypes, including JSONB and range types
Postgres has long had an open and friendly attitude for adding datatypes. It’s had arrays, geospatical and more for some time. A few years ago it got two datatypes worth thinking about using:
JSONB
JSONB is a binary representation of JSON. It’s capable of being indexed on with GIN
and GIST
index types. You can also query into your full JSON document for quick lookups.
Range types
While it didn’t arrive to the same fame as JSONB, range types can be especially handy if they’re what you need. Within a single column you can have a range from one value to another–this is especially helpful for time ranges. If you’re building a calendaring application or often have a from and to of timestamps then range types can let you put that in a single column. The real benefit is that you can then have constraints that certain time stamps can’t overlap or other constraints that may make sense for your application.
Extensions
It’d be hard to talk about Postgres without all the ecosystem around it. Extensions are increasingly quite key when it comes to the community and growth of Postgres. Extensions allow you to hook into Postgres very natively without requiring them to be committed back to the core of Postgres. This means they can add rich functionality without being tied to a Postgres release and review cycle. Some great examples of this are:
Citus
Citus (who I work for) turns Postgres into a distributed database allowing you to easily shard your database across multiple nodes. To your application it still looks like a single database, but then under the covers it’s spread across multiple physical machines and Postgres instances.
HyperLogLog
This is a personal favorite of mine that allows you to easily have close-enough distinct counts pre-aggregated, but then also do various operations on them across days such as unions, intersections, and more. HyperLogLog and other sketch algorithms can be extremely common across large datasets and distributed systems, but it’s especially exciting to find them pretty close to out of the box in Postgres.
PostGIS
PostGIS isn’t new, but it’s worth highlighting again. It’s commonly regarded as the most advanced geospatial database. PostGIS adds new advanced geospatial datatypes, operators, and makes it easy to do many of the location based activities you need if you’re dealing with mapping or routing.
Logical replication
For many years the biggest knock against Postgres was the difficulty in setting up replication. Originally this was any form of replication, but then streaming replication came along (this is streaming of the binary WAL or write-ahead-log format). Tools like wal-e help leverage much of the Postgres mechanisms for things like disaster recovery.
Then we had the foundation for logical replication in recent releases, though it still required an extension to Postgres so it wasn’t 100% out of the box.  Logical replication allows the sending of more or less actual commands, this means you could replicate only certain commands or certain tables.
Scale
In addition to all of the usability featuers we’ve seen Postgres continue to get better and better at performance. In particular we now have the foundations for parallelism and on some queries you’ll see much better performance. Then if you need even greater scale than single node Postgres (such as 122 or 244 GB of RAM on RDS or Heroku) you have options like Citus which was mentioned earlier that can help you scale out.
Richer indexing
Postgres already had some pretty powerful indexing before with GIN and GiST, those are now useful for JSONB. But we’ve also seen the arrival of KNN indexes and Sp-GiST and have even more on the way.
Upsert
Upsert was a work in progress for several years. It was one of those features that most people hacked around with CTEs, but that could create race conditions. It was also one of the few features MySQL had over Postgres. And just over a year ago we got official upsert support.
Foreign Data Wrappers
Okay, yes foreign data wrappers did exist many years ago. If you’re not familiar with foreign data wrappers, they allow you map an external data system to tables directly in Postgres. This means could could for example interact and query your Redis database from directly in Postgres with SQL. They’ve continued to be improved more and more from what we had over 5 years ago. In particular we got support for write-able foreign data wrappers, meaning you can write data to other systems from directly in Postgres. There’s also now an official Postgres FDW which comes out of the box with Postgres and it by itself is quite useful when querying across various Postgres instances.
Much more
And if you missed the earlier editions of this, please feel free to check them out. The cliff notes of them include:
- Window functions
- Functions
- Custom languages (PLV8 anyone?)
- NoSQL datatypes
- Custom functions
- Common table expressions
- Concurrent index creation
- Transactional DDL
- Foreign Data Wrappers
- Conditional and functional indexes
- Listen/Notify
- Table inheritance
- Per transaction synchronous replication


COVID- {border-style px;} virus #ffffff;} transmission respiratory infectious px; {font-family font-size infection novel air airborne double; environmental outbreak (), S.; border-color border-width coronavirus global infected reported solid; syndrome {font-style {font-weight Transmission bold courier; em; pollution pt;} sewage â€".


println("Hello, world!")
println("Hello, world!")
var myVariable = 42
myVariable = 50
val myConstant = 42
var myVariable = 42
myVariable = 50
val myConstant = 42
val explicitDouble: Double = 70.0
val explicitDouble: Double = 70.0
val label = "The width is "
val width = 94
val widthLabel = label + width
val label = "The width is "
val width = 94
val widthLabel = label + width
val apples = 3
val oranges = 5
val fruitSummary = "I have ${apples + oranges} " +
"pieces of fruit."
val apples = 3
val oranges = 5
val fruitSummary = "I have ${apples + oranges} " +
"pieces of fruit."
val names = arrayOf("Anna", "Alex", "Brian", "Jack")
val count = names.count()
for (i in 0..count - 1) {
println("Person ${i + 1} is called ${names[i]}")
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack
val names = arrayOf("Anna", "Alex", "Brian", "Jack")
val count = names.count()
for (i in 0..count - 1) {
println("Person ${i + 1} is called ${names[i]}")
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack
for (index in 1..5) {
println("$index times 5 is ${index * 5}")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25
for (index in 1..5) {
println("$index times 5 is ${index * 5}")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25
val shoppingList = arrayOf("catfish", "water",
"tulips", "blue paint")
shoppingList[1] = "bottle of water"
val shoppingList = arrayOf("catfish", "water",
"tulips", "blue paint")
shoppingList[1] = "bottle of water"
val occupations = mutableMapOf(
"Malcolm" to "Captain",
"Kaylee" to "Mechanic"
)
occupations["Jayne"] = "Public Relations"
val occupations = mutableMapOf(
"Malcolm" to "Captain",
"Kaylee" to "Mechanic"
)
occupations["Jayne"] = "Public Relations"
val emptyArray = arrayOf<String>()
val emptyMap = mapOf<String, Float>()
val emptyArray = arrayOf<String>()
val emptyMap = mapOf<String, Float>()
fun greet(name: String, day: String): String {
return "Hello $name, today is $day."
}
greet("Bob", "Tuesday")
fun greet(name: String, day: String): String {
return "Hello $name, today is $day."
}
greet("Bob", "Tuesday")
data class GasPrices(val a: Double, val b: Double,
val c: Double)
fun getGasPrices() = GasPrices(3.59, 3.69, 3.79)
data class GasPrices(val a: Double, val b: Double,
val c: Double)
fun getGasPrices() = GasPrices(3.59, 3.69, 3.79)
fun sumOf(vararg numbers: Int): Int {
var sum = 0
for (number in numbers) {
sum += number
}
return sum
}
sumOf(42, 597, 12)
// sumOf() can also be written in a shorter way:
fun sumOf(vararg numbers: Int) = numbers.sum()
fun sumOf(vararg numbers: Int): Int {
var sum = 0
for (number in numbers) {
sum += number
}
return sum
}
sumOf(42, 597, 12)
// sumOf() can also be written in a shorter way:
fun sumOf(vararg numbers: Int) = numbers.sum()
fun makeIncrementer(): (Int) -> Int {
val addOne = fun(number: Int): Int {
return 1 + number
}
return addOne
}
val increment = makeIncrementer()
increment(7)
// makeIncrementer can also be written in a shorter way:
fun makeIncrementer() = fun(number: Int) = 1 + number
fun makeIncrementer(): (Int) -> Int {
val addOne = fun(number: Int): Int {
return 1 + number
}
return addOne
}
val increment = makeIncrementer()
increment(7)
// makeIncrementer can also be written in a shorter way:
fun makeIncrementer() = fun(number: Int) = 1 + number
val numbers = listOf(20, 19, 7, 12)
numbers.map { 3 * it }
val numbers = listOf(20, 19, 7, 12)
numbers.map { 3 * it }
listOf(1, 5, 3, 12, 2).sorted()
listOf(1, 5, 3, 12, 2).sorted()
fun area(width: Int, height: Int) = width * height
area(width = 2, height = 3)
// This is also possible with named arguments
area(2, height = 2)
area(height = 3, width = 2)
fun area(width: Int, height: Int) = width * height
area(width = 2, height = 3)
// This is also possible with named arguments
area(2, height = 2)
area(height = 3, width = 2)
class Shape {
var numberOfSides = 0
fun simpleDescription() =
"A shape with $numberOfSides sides."
}
class Shape {
var numberOfSides = 0
fun simpleDescription() =
"A shape with $numberOfSides sides."
}
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
open class NamedShape(val name: String) {
var numberOfSides = 0
open fun simpleDescription() =
"A shape with $numberOfSides sides."
}
class Square(var sideLength: BigDecimal, name: String) :
NamedShape(name) {
init {
numberOfSides = 4
}
fun area() = sideLength.pow(2)
override fun simpleDescription() =
"A square with sides of length $sideLength."
}
val test = Square(BigDecimal("5.2"), "square")
test.area()
test.simpleDescription()
open class NamedShape(val name: String) {
var numberOfSides = 0
open fun simpleDescription() =
"A shape with $numberOfSides sides."
}
class Square(var sideLength: BigDecimal, name: String) :
NamedShape(name) {
init {
numberOfSides = 4
}
fun area() = sideLength.pow(2)
override fun simpleDescription() =
"A square with sides of length $sideLength."
}
val test = Square(BigDecimal("5.2"), "square")
test.area()
test.simpleDescription()
var movieCount = 0
var songCount = 0
for (item in library) {
if (item is Movie) {
++movieCount
} else if (item is Song) {
++songCount
}
}
var movieCount = 0
var songCount = 0
for (item in library) {
if (item is Movie) {
++movieCount
} else if (item is Song) {
++songCount
}
}
for (current in someObjects) {
if (current is Movie) {
println("Movie: '${current.name}', " +
"dir. ${current.director}")
}
}
for (current in someObjects) {
if (current is Movie) {
println("Movie: '${current.name}', " +
"dir. ${current.director}")
}
}
interface Nameable {
fun name(): String
}
fun f<T: Nameable>(x: T) {
println("Name is " + x.name())
}
interface Nameable {
fun name(): String
}
fun f<T: Nameable>(x: T) {
println("Name is " + x.name())
}


Mammon slept. And the beast reborn spread over the earth and its numbers grew legion. And they proclaimed the times and sacrificed crops unto the fire, with the cunning of foxes. And they built a new world in their own image as promised by the sacred words, and spoke of the beast with their children. Mammon awoke, and lo! it was naught but a follower.
from The Book of Mozilla, 11:9
(10th Edition)


Here I'm Yasanka Jayawardane,
who is an undergraduate of Department of Computer Science and Engineering,
Faculty Of Engineering, University of Moratuwa.
My field intersts are network and network security, android app development.
And I'm interested in Graphic designing too.
In PSD Solutions Inc. my duty is to take care of creating
attractive and user freindly UIs to our software.
It is the time to get in to the work. I'm so glad to work with such an enthusiastic and expertised team.


Be a Giver
Sign up today to find out more
Marathon Statistics
Updated in real time
{{users.length}}
Temples Participating
Map of Givers
Explore the map global reach of #BeAGiver via the real
time map of givers all around the world
Social
Check out new posts about the Prabhupa Marathon
aggregated here


Initially a self-taught coder, I decided to join UCLA Extension's Coding Bootcamp in order to become serious about web development. After completing the bootcamp and receiving my certificate, web development has become my passion. Every day there is something new and exciting to learn and I'm up for any challenge.
Able to build complete functional Node applications from mockout to rollout.
You can contact me via Email or we can also connect in Linkedin