X-Frame-Options ALLOW-FROM set but not in CSP frame-ancestors domains
X-Frame-Options ALLOW-FROM set but no CSP frame-ancestors
CSP frame-ancestors set but no X-Frame-Options ALLOW-FROM
CSP frame-ancestors 'self' set but no X-Frame-Options SAME-ORIGIN
X-Frame-Options SAME-ORIGIN set but no CSP frame-ancestors 'self'
CSP frame-ancestors 'none' set but no X-Frame-Options DENY
X-Frame-Options DENY set but no CSP frame-ancestors 'none'


A tiny app that allows you to take notes by recording your voice
Press the Start Recording button and allow access.
You don't have any notes.
{{final_summary}}


Venom: Marvel Starts to Seed Its Next Symbiote Event in February
by Sam StoneWhile Absolute Carnage may have just come to a thrilling end, Eddie Brock's troubles with the symbiotes are only getting deadlier in the pages of Venom.
Marvel Comics has released its solicitation information for titles going on sale in February 2020, including Venom #23, by Donny Cates and Mark Bagley. A continuation of the creative team's "Venom Island" storyline kicking off next month, the solicit teases the issue is the start of the build-up to the next major symbiote-centric event in the Marvel Universe.
VENOM #23
- DONNY CATES (W) • MARK BAGLEY (A/C)
- VARIANT COVER BY SKOTTIE YOUNG
- GWEN STACY VARIANT COVER BY HUMBERTO RAMOS
- VENOM ISLAND COMES ALIVE!
- • They say there’s no rest for the wicked, and few creatures in the Marvel Universe are as wicked as CARNAGE.
- • Face front, readers -- the seeds of next year’s VENOM event are already beginning to grow…
- 32 PGS./Rated T+ …$3.99
Absolute Carnage served as the culmination of Cates' run on Venom to that point, with over a year of build-up. However, with the solicit teasing even bigger things to come, Cletus Kasady may have been the least of Eddie's worries.
Venom #23, by Donny Cates and Mark Bagley, goes on sale in February 2020 from Marvel Comics.
https://schema.orgBreadcrumbListListItem1Homehttps://www.cbr.com/ListItem2Comicshttps://www.cbr.com/category/comics/ListItem3Comic Newshttps://www.cbr.com/category/comics/news/ListItem4Venom: Marvel Starts to Seed Its Next Symbiote Event in Februaryhttps://www.cbr.com/marvel-venom-symbiote-event-february/


| densplot {coda} | R Documentation |
Displays a plot of the density estimate for each variable in x
,
calculated by the density
function. For discrete-valued
variables, a histogram is produced.
densplot(x, show.obs = TRUE, bwf, ylim, xlab, ylab = "", type="l", main, right=TRUE, ...)
x |
An |
show.obs |
Show observations along the x-axis |
bwf |
Function for calculating the bandwidth. If omitted, the bandwidth is calculate by 1.06 times the minimum of the standard deviation and the interquartile range divided by 1.34 times the sample size to the negative one fifth power |
ylim |
Limits on y axis. See |
xlab |
X-axis label. By default this will show the sample size
and the bandwidth used for smoothing. See |
ylab |
Y-axis label. By default, this is blank. See |
type |
Plot type. See |
main |
An overall title for the plot. See |
right |
Logical flag for discrete-valued distributions passed to
the |
.
... |
Further graphical parameters |
For discrete-valued distributions, a histogram is produced and values
are aggregated using the pretty() function. By default, tick marks
appear to the right of the corresponding bar in the histogram and give
the inclusive upper limit of the hist (right=TRUE
). This can be
modified by specifying right=FALSE
. In this case tick marks
appear on the left and specify the inclusive lower limit of the bar.
For continous distributions, if a variable is bounded below at 0, or bounded in the interval [0,1], then the data are reflected at the boundary before being passed to the density() function. This allows correct estimation of a non-zero density at the boundary.
You can call this function directly, but it is more usually called by
the plot.mcmc
function.


18.6 Distributed Computing
There
are many standards for distributed computing, from simple Remote
Procedure Call (RPC) ones to rich object-oriented ones such as CORBA.
You can find several third-party Python modules supporting these
standards on the Internet.
The Python standard library comes with support for both server and
client use of a simple yet powerful standard known as XML-RPC. For
in-depth coverage of XML-RPC, I recommend the book
Programming Web Services with XML-RPC, by Simon
St. Laurent and Joe Johnson (O'Reilly). XML-RPC uses
HTTP as the underlying transport and encodes requests and replies in
XML. For server-side support, see Section <IP_ADDRESS> in Chapter 19. Client-side support is supplied by module
xmlrpclib.
The
xmlrcplib module supports a class
ServerProxy, which you instantiate to connect to
an XML-RPC server. An instance s of
ServerProxy is a proxy for the server it connects
to. In other words, you call arbitrary methods on
s, and s
packages up the method name and argument values as an XML-RPC
request, sends the request to the XML-RPC server, receives the
server's response, and unpackages the response as
the method's result. The arguments to such method
calls can be of any type supported by XML-RPC:
- Boolean
-
Constant attributes True and
False of module xmlrpclib
(since module xlmrpclib predates the introduction
of bool into Python, it does not use
Python's built-in True and
False values for this purpose)
- Integers, floating-point numbers, strings, arrays
-
Passed and returned as Python int,
float, Unicode, and
list values
- Structures
-
Passed and returned as Python dict values whose
keys must be strings
- Dates
-
Passed as instances of class xmlrpclib.DateTime;
value is represented in seconds since the epoch, as in module
time (see Chapter 12)
- Binary data
-
Passed as instances of class xmlrpclib.Binary;
value is an arbitrary string of bytes
Module xmlrpclib supplies two factory functions.
Creates and returns an instance of
Binary wrapping the given
bytestring.
Creates and returns an instance of
Boolean with the truth value of
x.
Module xmlrpclib supplies several classes.
x is a Python string of arbitrary bytes.
b represents the same bytes as an XML-RPC
binary object.
x is any Python value, and
b has the same truth value as
x.
x is a number of seconds since the epoch,
as used in module time, covered in Chapter 12.
If the server at the given url supports
introspection, s supplies an attribute
s.server that in turn
supplies three methods:
- s.server.listMethods( )
-
Returns a list of strings, one per each method supported by the
server.
- s.server.methodSignature( name)
-
Returns a list of strings, each a
signature of method name on the server. A
signature string is composed of type names separated by commas: first
the type of the return value, then the type of each argument. When
method name has no defined signature,
s.server.methodSignature(name)
returns some object that is not a list.
- s.server.methodHelp( name)
-
Returns a string with help about method
name. The string can be either plain text
or HTML. When the method name has no
defined help,
s.server.methodHelp(name)
returns an empty string ''.
The following example uses xmlrpclib to access
O'Reilly's Meerkat open wire
service (see http://www.oreillynet.com/meerkat/
for more information about Meerkat) and displays the last few news
items about Python.
import xmlrpclib
proxy = xmlrpclib.ServerProxy(
'http://www.oreillynet.com/meerkat/xml-rpc/server.php')
results = proxy.meerkat.getItems({'search':'Python', 'num_items':7})
want_keys = 'title link description'.split( )
n = 0
for result in results:
n = n + 1
for key in want_keys:
print '%d. %s: %s' % (n, key.title( ), result.get(key))
print
|


Ways To Lose Belly Fat: Follow These Lifestyle Changes To Reduce Belly Fat
by Soumil KFashion
There are many ways to lose belly if you are serious about it, and you should be! Read ahead to know more about ways to reduce belly fat and tone belly fat.
Written By Soumil K | Mumbai | Updated On: November 22, 2019 08:48 IST
Belly fat also known as visceral fat is a major risk factor for type 2 diabetes, heart disease and other conditions.  Here are a few ideas which can help you reduce that belly fat.
Also Read: Belly Fat Cells May Be Targets For Age Related Diseases: Study
Lifestyle and Diet change:
Include more protein in your diet. Add foods like whole eggs, fish, seafood, legumes, nuts, meat and dairy products in your daily meals. Avoid sugar and aerated drinks. Cut carbs from your diet. When it comes to portion size, make sure it is as much as the size of your palm. Eat on time and make sure your breakfast is heavy and dinner is very light.
Also Read: Diet: Here Are The Details You Need To Know About The Zero Belly Diet
Drink more water
Consistently drinking water throughout the day is also important. Drinking water leads to more active metabolism. It also helps your body flush out toxins improving overall health. Drink fresh fruit juices, coconut water and keep yourself hydrated.
Exercise:
There is no substitute for exercise when it comes to losing belly fat. The best way to tackle belly fat is by doing crunches. Crunches have various variations. Start with basic crunches and then move on to side crunches, reverse crunches, vertical leg crunch, bicycle crunches and Russian twists. You can also do cardio as it helps burn calories and unwanted fat. Brisk walking for one hour daily will also help in the long run to achieve overall fitness.
Also Read: Belly Fat: How To Reduce Unwanted Belly Fat With Easy Workouts
Limit alcohol intake
Alcohol intake is associated with bigger bellies because when you drink alcohol the liver burns alcohol instead of fat. Excess alcohol also means excess calories. Not to forget, the food that gets consumed with the alcohol also adds to the calorie count and aids to the belly fat. It is advisable to limit alcohol intake if you can't stop it entirely.
Also Read: Weight Loss: Walking For Losing Weight | Reduce Belly Fat In 10 Easy Steps
The content provided above is for information purpose. This is no way intended to be a substitute for professional medical advice, diagnosis, or treatment. Always seek the advice of your physician or other qualified health providers with any questions you may have regarding a medical condition.


Use me to get on Google's search results!!!
use stong instead of bold and em instead of i
use ins instead of u (underline)
use sup and sub text
use del for deleted text


#?
[companyName]
[companyAddress]
Recipient:
Recipient name
Recipient addressServices provided:
| Description | Amount () |
| Description of service provided | [currency]Amount |
| Total due: | [currency][sum(amount)] |
| Description | Amount () |
| Description of service provided | [currency]Amount |
| Total due: | [currency][sum(amount)] |


Architecture
The basic architecture consists of four layers, which correspond with the package structure:
- api; Facade for bean and row, used to have a single class for interacting the underlying layers
- bean; layer responsible for translating rows to Beans.
- row; layer responsible for translating tokens to lines and lines to headers and rows.
- token; layer responsible for parsing the CSV file one symbol at a time and translating those to tokens and lines.
Furthermore, there are two auxiliary packages:
- report; structure for reporting back errors with references to the original CSV row
- annotations; various annotations for instructing the bean, row and token classes.
api
Design goal: a single Facade for interacting with the underlying layers, intuitive in usage and operation
CsvClient joins both BeanReader and LineReader, and their respective instructions classes in a single class. Developers making use of the Facade now only have to deal with one class to drive the process.
bean
Design goal: user-friendly (ie, low-maintenance for user) way of converting CSV rows into Beans
This is where Rows are converted to Beans. This process makes use of the original Mapping strategy, which is either column index or column name based:
- column index mapping; used by default, executed by the ColumnIndexMapper. Maps found cells to Bean properties by their index of the column in the CSV file.
- column name mapping; executed by the ColumnNameMapper. Maps found cells to Bean properties by the header name of the column in the CSV file.
All mappable cells are converted to the Bean property using Converters. Custom Converters can be configured as well.
row
Design goal: collecting headers and rows, while maintaining links to the original line text for later reference
Lines are read in their bare form. When headers are used, the first read line will be converted to a Header, whereas the others are all Row instances. The layer takes into account the needs for jumping to the start line, and skipping empty or comment lines. Only valid lines are offered for conversion to a Header/Row.
Whenever a line is read in the row layer, it is stored together with information on its original CSV line. This information contains two important aspects:
- start and end of columns
- non-printable characters made printable
Users can directly read Rows, with their Header and extra information.
token
Design goal: most versatile and effective way of tokenizing CSV files, without forward reading, one symbol at a time
The tokenizer is made on a state machine. The state machine gets one symbol at the time and on the basis of its current state, it can determine its next state. The state machine is capable of saying whether tokens must be returned (ie, a cell has been read), or lines are finished. The states are fixes and cannot be configured. Most meaningful symbols (except SPACE and END-OF-FILE) can be configured.
report
Design goal: ability to trace back errors on a property to the original cell in the CSV line, even after the conversion process has taken place
When an error occurs, the exception can be fed with exact details on the position of the cell in the CSV line, meaning that lines can be printed showing precisely the location of the error.
annotations
Design goal: an intuitive way of defining parsing and mapping instructions directly associated with the Bean class and properties
Annotations have a big advantage of the declarative model, which is that the elements they describe are hard-coupled with the instruction. The declarative model on the other hand, is a soft-coupling, more prone to failure, such as name changes that go unnoticed.
Annotations and the declarative model are mirrored, so that everything that can be declared with annotations can also be declared programmatically and vice versa.


{% extends 'base.html' %} {% block content %}
The link you have accessed does not currently exist.
Check out the About Us page to contact the group if you need information.


Declarations for the NumericSymbol class. More...
Go to the source code of this file.
Declarations for the NumericSymbol class.


User : albee1pb Workflow UUID : EA8C633D-BD3C-4FFE-9624-2D4CE803B388 File Name : Cappuccino-Fresco-Print-C10291481.jpeg
Testing


FsiEvaluationSessionHostConfig
Namespace: FSharp.Compiler.Interactive
Parent Module: Shell
Constructors
| Constructor | Description |
new()
Signature: unit -> FsiEvaluationSessionHostConfig
|
CompiledName: |
Instance members
| Instance member | Description |
AddedPrinters
Signature: Choice<(Type * (obj -> string)),(Type * (obj -> obj))> list
Modifiers: abstract |
Called by the evaluation session to ask the host for parameters to format text for output CompiledName: |
EventLoopInvoke(codeToRun)
Signature: (codeToRun:(unit -> 'T)) -> 'T
Modifiers: abstract Type parameters: 'T |
Request that the given operation be run synchronously on the event loop. |
EventLoopRun()
Signature: unit -> bool
Modifiers: abstract |
Called by the evaluation session to ask the host to enter a dispatch loop like Application.Run(). Only called if --gui option is used (which is the default). Gets called towards the end of startup and every time a ThreadAbort escaped to the backup driver loop. Return true if a 'restart' is required, which is a bit meaningless. |
EventLoopScheduleRestart()
Signature: unit -> unit
Modifiers: abstract |
Schedule a restart for the event loop. |
FloatingPointFormat
Signature: string
Modifiers: abstract |
Called by the evaluation session to ask the host for parameters to format text for output CompiledName: |
FormatProvider
Signature: IFormatProvider
Modifiers: abstract |
Called by the evaluation session to ask the host for parameters to format text for output CompiledName: |
GetOptionalConsoleReadLine(...)
Signature: probeToSeeIfConsoleWorks:bool -> (unit -> string) option
Modifiers: abstract |
Indicate a special console "readline" reader for the evaluation session, if any. A "console" gets used if --readline is specified (the default on Windows + .NET); and --fsi-server is not given (always combine with --readline-), and OptionalConsoleReadLine is given. When a console is used, special rules apply to "peekahead", which allows early typing on the console. Peekahead happens if --peekahead- is not specified (the default). In this case, a prompt is printed early, a background thread is created and the OptionalConsoleReadLine is used to read the first line. If a console is not used, then inReader.Peek() is called early instead. Further lines are read using OptionalConsoleReadLine(). If not provided, lines are read using inReader.ReadLine(). |
OnEvaluation
Signature: IEvent<EvaluationEventArgs>
|
Hook for listening for evaluation bindings CompiledName: |
PrintDepth
Signature: int
Modifiers: abstract |
Called by the evaluation session to ask the host for parameters to format text for output CompiledName: |
PrintLength
Signature: int
Modifiers: abstract |
Called by the evaluation session to ask the host for parameters to format text for output CompiledName: |
PrintSize
Signature: int
Modifiers: abstract |
Called by the evaluation session to ask the host for parameters to format text for output CompiledName: |
PrintWidth
Signature: int
Modifiers: abstract |
Called by the evaluation session to ask the host for parameters to format text for output CompiledName: |
ReportUserCommandLineArgs(arg1)
Signature: (string []) -> unit
Modifiers: abstract |
The evaluation session calls this to report the preferred view of the command line arguments after stripping things like "/use:file.fsx", "-r:Foo.dll" etc. |
ShowDeclarationValues
Signature: bool
Modifiers: abstract |
Called by the evaluation session to ask the host for parameters to format text for output CompiledName: |
ShowIEnumerable
Signature: bool
Modifiers: abstract |
Called by the evaluation session to ask the host for parameters to format text for output CompiledName: |
ShowProperties
Signature: bool
Modifiers: abstract |
Called by the evaluation session to ask the host for parameters to format text for output CompiledName: |
StartServer(fsiServerName)
Signature: fsiServerName:string -> unit
Modifiers: abstract |
The evaluation session calls this at an appropriate point in the startup phase if the --fsi-server parameter was given |
UseFsiAuxLib
Signature: bool
Modifiers: abstract |
Implicitly reference FSharp.Compiler.Interactive.Settings.dll CompiledName: |


{% if title %}
{{ title }} - Recipeat
{% else %}
Welcome to Recipeat
{% endif %}
RecipEat
Logged in as {{ username }}!
Go to main page.
Leaving already?
Click here to log out.


Multilingual Microservices
What is Microservice?
Componentized - Microservices should be very small with a single responsibility and be out of process. This is very different from a typical library where components are assembled in process.
Message Driven - Microservices should be driven by asynchronous messaging where the intelligence is left up to the microservice implementation and not provided by the messaging fabric
Decentralized Data - Each service should manage its own data. You can think of this model as the OO concept of data encapsulation. No service can access the database of another service.
software that fits in your head.
Dan North, @tastapod
Can we do everything with one tool?
O'REALLY?
Use right tool!
Be together, not the same!
Could be applied also to micros-ervices.
Server-Web Client communication (JavaScript)?
NodeJS
Writing buisness logic (complex structures,relations)?
Java / C# / Dart
Parallel computations, data manipulation?
C++ / Go
...you tell me!
Erlang, Scala, Python
Each Language/Platform has own
SDK
Packages
Builder
Containers!
Container
Management System
Swarm
is a Docker.. Simple to use, hard for complex scheduling
Fleet
Low-level and simple orchestration tooling
Low-level, battle-hardened scheduler
Kubernetes
Opinionated orchestration tool that comes with service discovery and replication baked-in
Opiniated by Google
14 Data Centers
How many servers there are?
1837440
Google Spanner
~10^6 to 10^7 machines, ~10^13 directories,
~10^18 bytes of storage, spread at 100s to 1000s of
locations around the world, ~10^9 client machines
Let's Build!
Kubernetes
Serve HTML templates, accept user requests [frontend]
Get request form front-end and pass to renderer [dispatcher]
Render actual picture requested [renderer]
Test locally
Dockerize
Deploy to Cloud
Demo
Valentyn Shybanov
<EMAIL_ADDRESS>http://olostan.name
Kudos to Dan North @tastapod, Dejan Glozic @dglozic,Martin Fowler @martinfowler, Google, and other great people who
contribute in understanding and implementing micro-services. Special thanks to Google for their great products.
Using different programming languages in microservice architecture
and deployed on Google Cloud Platform
My name is Valentyn Shybanov, olostan.name. I am
Software Architect in Twinfield.
Let me mention some main properties of microservices:
One of the most discussed question is how big microserive should be. 100 LoC? 1000? My most
favourite answer is Den North's definiting: Software that fits in your head
But can we do everything with using same tool?
May be we can have universal "swiss knife"
that we can use to develop all our multiservices?
Try to hit nail with swiff knife
Especially when there is tools designed for that
There is a slogan from Android that can be applied to microservices
Here are samples of tools that can suite much better for solving specified problems
But each of platform bring own problems
Each of them have own SDK, Package System, Builders, Compilers, Linting, etc
Good solution for these problems is to use containers.
Tehy looks like a great solution for the first view - inside is wrapped all
complexity, all dependent components, it is easy to run on any system with just "docker run".
But when there are 2 containers, you need to think how to manage them. Deploy in the
way that will not ruin your system.
When there are more you need to think about possible dependencies between them
And it becomes horrow when new and new containers appears
Solution for that can to to use container management system that will take over
deployement, assembling containers to the system. There are couple of them:
Swarm is really Docker-oriented. For complex solutions you need to implement own way
of managing these containers.
CoreOs' Fleet give a very fine control over cluster where containers could be run, but
it is quite simple and primitive. Again for complex scenarios you need to implement own extra layer of management
Mesos is the olderst, and it is not exactly container oriented. It is good for managing cluster,
but not well suited for managing container-based solutions
Kubernetes from Google has own concepts (Pods, Replication Controllers) that are
quite opiniated, but gives fool control over the cluster and containers. It handles name resolution, container dependecy resolving etc
Ti is opiniated by Google. Can we trust Google that their solution is good enough?
Google has 14 datacenters whole over the world. how many servers they operate?
There is no public information, but we can estimate at least approximately (using Google Maps and
calculate number of servers that could be fir inside area occupied by Data Centers
Another approximation could be done from Jeff Dean's preseentation about Google Spanner that
is designed to operate on 10^6 to 10^7 servers
Let's build sample application using multiple languages
We'll use NodeJS for frontend because it use same platform as client (JS), Java
for buisness logic and Go for manipulation with data. gRPC for communicate between them.
We'll use Kubernetes to orchestrate these containers
And we'll deploy to the cluster running on Google Cloud Platform
First we need to define contract using Protobuf definition. The most important
part here - "service" part where we define what is exposed by our server
For Java we can use grpc grandle plugin that will generate Java interfaces that needed
to be implemented and classes that can be used for exposing services using Netty server
Just implemented generated interfaces you can expose service. You can use generated
classes to form response and send it back
As for Go service we should define same contract (protobuf definition does not depend
to language that is going to implement it or usee it as client).


chunked_pmap
pulls chunks from a database result set and
applies a function to each row of the result set. All transformed chunks
are row bound to return a single dataframe.
chunked_pmap(res, f, n, gc = NA_character_)
DBI::dbSendQuery
result set.f
is assumed to be constructed using a dplyr
pipeline
where a dataframe is passed as the sole parameter and a transformed dataframe
is returned.NA
or no
garbage collection.
This function is useful when processing database result sets that are
extremely large. For example, if XML docs, JSON docs, or blobs of any kind
are stored in a database column, then chunked_pmap
can be
used to iteratively process and transform the data.
pmap
rowwise
## Not run: ------------------------------------ # # create in-memory SQLite database # dbcon <- DBI::dbConnect(RSQLite::SQLite(), dbname = ":memory:") # DBI::dbWriteTable(dbcon, "mtcars", mtcars) # # # create and send a query # sql_query <- "SELECT * FROM mtcars where hp > 120" # res <- DBI::dbSendQuery(dbcon, sql_query) # # # create a function to operate on chunks # # the function should accept a dataframe and return a dataframe # f <- function(df) { # df %>% # dplyr::mutate(hp_to_cyl = hp / cyl) %>% # dplyr::arrange(hp_to_cyl) # } # # # process 5 rows at a time # mtcars_new <- chunked_pmap(res, f, 5) # # # cleanup # DBI::dbClearResult(res) # DBI::dbDisconnect(dbcon) ## ---------------------------------------------


Exercises Day 1
Problem 1: Introductory Programs
To begin with we will get the compiler up and running and make sure we can compile a simple program. Assuming you are using the GNU compiler for now, you can compile and run your program using the following commands
g++ -o program code.cpp
./program
One can pass compile flags to the compiler to tell it how it should compile, e.g. how strict it should be with warnings, whether it should compile with debugging support and so on and so forth. Since we will make use of the C++11 syntax, we have to tell the compiler that we are using the new standard. We can do this by calling
g++ -o program -std=c++11 code.cpp
./program
- Write a program that somehow makes use of the
auto
keyword and have your program compile and run - Write a program that reads two integers from standard input and prints the sum of the two
Problem 2: Integers and float
-
Try multiplying together two numbers so that the result is larger than the largest
int
and store the result in anint
, what happens? - Try the same with a floating point type
- Try dividing by zero and print the result
Advanced:
As you all know all data is stored in binary on a computer. For an unsigned 4bit integer this is of course done in the expected way, so that the number 5 is stored as 0101. For floating point numbers, this is somewhat more advanced where parts of the bit-content is dedicated to the decimals, and part of it is dedicated to the exponential factor. You can read more about this on Wikipedia. In this exercise we will try to make a program that writes out the bit-content of the various built in types of C++. This is most easily done with the bitwise operators in C++.
Problem 3: Infinite loops
-
Write an infinite loop that prints the number 42 to the terminal forever. Do this both with a
for
loop and awhile
loop. Hint: You can stop you program by pressing Ctrl-C -
Recreate the factorial function from the lecture using an infinite loop and a loop control statement
(
break
orcontinue
)
Problem 4: Checking for prime
- Write a program that reads an integer from the terminal and checks whether the number is a prime or not
- Make the program a bit more advance, and rather than simply checking whether it is a prime, also print out the primes it can be factorised to
Problem 5: Multi-dimensional arrays
- Write a small program that stores the 20x20 multiplication table in a 20x20 array
- Write code so that the array is printed to the screen in some organised fashion
Problem 6: A game of Mastermind
Finally we will try to write a game of Mastermind. Mastermind is basically a board game where the "codemaker" sets up a combination of 4 colours, and the player will try to guess those in 12 turns. With every guess the codemaker will tell the player how many of their guesses are both the right colour and position, as well as how many additional colours are right, but in the wrong position.
- Write a program that you can play mastermind with


This inspection finds all usages of methods that have
@since 1.5
tag in their documentation.
This may be useful when development is performed under J2SDK 5.0, while the target platform for production is still J2SDK 1.4.


menu
Markdown Site
Home
Add new article
Management
Log out
Markdown Site
Home
Add new article
Management
Log out
General settings
Access management
Role
Users
Paths
Roles for articles and folders (categories)
{{#available_folders}}
{{path}}
{{/available_folders}}
Choose path:
Current path's roles:
{{#available_roles}}
{{.}}
{{/available_roles}}
Choose one or several roles from existing
Or add new roles
Confirm
Delete path
Roles for users
{{#available_users}}
{{login}}
{{/available_users}}
User
Current user's roles
{{#available_roles}}
{{.}}
{{/available_roles}}
Choose one or several roles from existing
Or add new roles
Confirm changes
Delete user


Introducing Lanyon
02 Jan 2014Lanyon is an unassuming Jekyll theme that places content first by tucking away navigation in a hidden drawer. It's based on Poole, the Jekyll butler.
Built on Poole
Poole is the Jekyll Butler, serving as an upstanding and effective foundation for Jekyll themes by @mdo. Poole, and every theme built on it (like Lanyon here) includes the following:
- Complete Jekyll setup included (layouts, config, 404, RSS feed, posts, and example page)
- Mobile friendly design and development
- Easily scalable text and component sizing with
rem
units in the CSS - Support for a wide gamut of HTML elements
- Related posts (time-based, because Jekyll) below each post
- Syntax highlighting, courtesy Pygments (the Python-based code snippet highlighter)
Lanyon features
In addition to the features of Poole, Lanyon adds the following:
- Toggleable sliding sidebar (built with only CSS) via ☰ link in top corner
- Sidebar includes support for textual modules and a dynamically generated navigation with active link support
- Two orientations for content and sidebar, default (left sidebar) and reverse (right sidebar), available via
<body>
classes - Eight optional color schemes, available via
<body>
classes
Head to the readme to learn more.
Browser support
Lanyon is by preference a forward-thinking project. In addition to the latest versions of Chrome, Safari (mobile and desktop), and Firefox, it is only compatible with Internet Explorer 9 and above.
Download
Lanyon is developed on and hosted with GitHub. Head to the GitHub repository for downloads, bug reports, and features requests.
Thanks!


I'm the first content slide
I'm the second content slide
I'm the third content slide
I'm the fourth content slide
one
two
three
four


The Flash Pulls a Captain America Move in Latest Episode
by Meagan DamoreSPOILER WARNING: This article contains major spoilers for " License to Elongate," the latest episode of The Flash Season 6.
The Flash just pulled a page out of Captain America's book. In "License to Elongate," the latest episode, the Scarlet Speedster came face-to-face with Ultraviolet once again. However, instead of using his powers, he picked up a different tool to help: a shield.
This week, Barry joined Ralph Dibny's mission to find Sue Dearbon. Ralph's search led him to an auction, where the two Team Flash members found themselves surrounded by mob bosses and other types of criminal. Barry immediately wanted to turn speedster on them, but Ralph advised him not to, explaining that there was a time and place for that -- just not here.
Nevertheless, Barry suited up as the Flash. Unfortunately, the place was fitted with metahuman detectors, alerting the villains to their presence. Barry discovered that soon enough, when both he and Ralph were attacked from behind.
The two metahumans found themselves tied up, where they had a heart-to-heart about Barry's disappearance. Barry admitted Ralph was right, so -- when they escaped -- he agreed to follow Ralph's lead. That meant no powers, at least for the time being.
By the time Barry and Ralph got away, the villain's auction was underway. In addition to a massive weapon capable of destroying of cities, he had a number of valuables and artifacts on stage. One of those happened to be a gladiator shield, which Barry put to good use when Ultraviolet attacked.
On stage in front of the villains and due to his promise to Ralph, Barry couldn't become the Flash to save himself. As such, he used what was available to him on stage. He quickly picked up the shield, round like Cap's shield, and went on the offensive with it. He even ended up throwing it once, much like the popular Avenger.
Though he ultimately ditched the shield, Barry was able to overcome Ultraviolet while Ralph saved the day. Unfortunately, they didn't discover any additional information about Sue or her whereabouts, but that doesn't mean she's a lost cause. After all, The Originals star Natalie Dreyfuss was just cast to play the character, who will appear sometime later in Season 6.
Airing Tuesdays at 8 p.m. on The CW, The Flash stars Grant Gustin, Candice Patton, Carlos Valdes, Danielle Panabaker, Tom Cavanagh, Jesse L. Martin, Danielle Nicolet and Hartley Sawyer.
https://schema.orgBreadcrumbListListItem1Homehttps://www.cbr.com/ListItem2TVhttps://www.cbr.com/category/tv/ListItem3TV Newshttps://www.cbr.com/category/tv/news-tv/ListItem4The Flash Pulls a Captain America Move in Latest Episodehttps://www.cbr.com/flash-captain-america-shield-defense/


VxWorks port of NTP
Please look at the
Vxworks file
in the html directory.
Casey Crellin
casey@csc.co.za


Collations used for comparing strings can be specified by means of a URI. A collation URI may
be used as an argument to many of the standard functions, and
also as an attribute of xsl:sort
in XSLT, and in the order by
clause of a FLWOR expression in XQuery.
The W3C specifications leave the details of collation URIs entirely implementation-defined. This section explains the collation URIs that can be used with Saxon.
In Saxon XSLT stylesheets, collations may be described using a saxon:collation
element as a top-level declaration in the stylesheet. In this case the value of the name
attribute of the saxon:collation
may be used as a collation URI. There is no constraint
on the form this URI takes, indeed there is no requirement that it be a legal URI.
See saxon:collation for more details.
A collation URI may also be constructed directly. This enables collation URIs to be used in
XPath and XQuery applications as well as in XSLT stylesheets. Such a collation URI takes the form
http://saxon.sf.net/collation?keyword=value;keyword=value;...
. The query parameters
in the URI can be separated either by ampersands or semicolons, but semicolons are usually more
convenient. The keywords available are as follows:
|
keyword |
values |
effect |
|
class |
fully-qualified Java class name of a class that
implements |
This parameter should not be combined with any other parameter.
An instance of the requested class is created, and is used to perform
the comparisons. Note that if the collation is to be used
in functions such as contains() and starts-with(), this class must also be a
|
|
lang |
any value allowed for xml:lang, for example |
This is used to find the collation appropriate to a Java locale. The collation
may be further tailored using the parameters |
|
strength |
primary, secondary, tertiary, or identical |
Indicates the differences that are considered significant when comparing two strings. A/B is a primary difference; A/a is a secondary difference; a/� is a tertiary difference (though this varies by language). So if strength=primary then A=a is true; with strength=secondary then A=a is false but a=� is true; with strength=tertiary then a=� is false. |
|
decomposition |
none, standard, full |
Indicates how the collator handles Unicode composed characters. See the JDK documentation for details. |
It is also possible to specify the Unicode Codepoint Collation defined in the
W3C specifications, currently http://www.w3.org/2003/11/xpath-functions/collation/codepoint
.
In addition, the APIs provided for executing XPath and XQuery expressions allow named collations to be registered by the calling application, as part of the static context.


|
bottyworld
A 2D robot simulation that utilizes Elma
|
bottyworld is a 2D simulation of robot named "botty" that includes an intruder and a recharging battery. The creator is David Wu, student in ECEP520 (a.k.a. ECE590) - Software Engineering for Embedded Applications), for which the professor is Eric Klavins. This program was David's final project for this course.
NOTE: Be sure that your computer's sound is operational, and that the volume is turned up to a medium volume.
To run bottyworld, type
bin/bottyworld
When the bottyworld environment appears, botty is represented by "b". As he moves rather quickly in random directions throughout his world, his battery power dissipates.
You can influence the environment of bottyworld via these keys:
This project was intended to be an extension of the robot finite state machine, introduced to our class in Week 7 homework. The elma_project file structure, provided by Prof. Klavins, was used as the baseline for the project. The latest "elma:latest" docker container for compiling.
Using ncurses for the first time, I spent a lot of time learning how this application works, and I also spent a few days learning how the base elma_project handled states and transitions. A considerable amount of time and effort was spent figuring out how to convert the Homework 7 representation of the FSM, and convert it into the elma_project-style structure.
Part of the challenge of this project was the intepretation of the robot FSM, and how it can be represented in a user interface. I was able to get the Wander, Make Noise, and Evade states operating correctly, as well as the transitions between each.
I diverged from the original FSM to create a method of battery operation that was slightly more efficient (and aesthetically pleasing) than what I would have had to implement using the original structure.
I found that I worked best when I focused on getting a particular feature to work, as opposed to working on multiple integrated features at once. I made sure to save, for configuration management, the various successful stages of coding.
No one helped me with this project.
I used the following websites for reference:
ECE590 has been a challenging but also very rewarding course, and I (David Wu) hope to showcase what I have learned these past 10 weeks in this final project. For whatever reason, the idea of moving the FSM robot (part of homework from Week 7) into a 2D environment is the project option that caught my attention.
Please take note that the goals and other details listed below are subject to change/evolve as the project matures.
My goals for bottyworld are as follows:
I project that I will use the following resources:
This past week, I have been brainstorming on how I will approach the 2-dimensional space that Botty will wander in, as well as reviewing the elma_project files and structure.
I project that I will be creating a 10 x 10 grid that looks similar to the following:
= = = = = = = = = =
= = = = = = = = = =
= B = = = = = = = =
= = = = = = = = = =
= = = = = = = = = =
= = = = = = = = = =
= = = = = = I = = =
= = = = = = = = = =
= = = = = = = = = =
= = = = = = = = = ^
Here is an explanation of the characters in the grid. Note that these might be replaced by other characters depending on the capability of ncurses:
My updated milestones for this project are as follows:
I also started learning how ncurses works, and also have been studying the way that elma_project works. I can get the base elma_project to compile properly in the latest docker container made available by Prof. Klavins. (At the time of this writing, the code in the above structure here compiles fine.)
At this point, I am still figuring out how to "convert" the given stopwatch example in elma_project to become the template for bottyworld.


Extracted details
| Processed text | |
|---|---|
| Total words count | |
| Unique words count |
Unique words and individual count
Unique occurences distribution
Graph will be displayed here
words not shown (arc less than degrees)
Text analysis
Text changed - data displayed is not accurate - request data again to get accurate results


{{issue.title}}
{{issue.description}}
{{issue.link}}
{{issue.cve}}
{{issue.etc_numbering}}
{{issue.reward}}


Changes to Metis
Recent Changes
- Fixed a bug that crashed Metis when mutually rewriting disequality
literals discovered by Martin Desharnais and Jasmin Blanchett.
- Fixed a bug that prevented clauses from being fully simplified
discovered by Martin Desharnais and Jasmin Blanchett.
Version 2.4: 1 March 2018
- Moved development of Metis to
GitHub
and archiving
releases
there to enable build reproducibility.
- Added a
--time-limit N
command line argument.
- Fixed a soundness bug in the CNF normalization discovered by Jonathan Prieto-Cubides.
- Fixed two incompleteness bugs in the proof engine discovered by Michael Farber.
Version 2.3: 11 September 2010
- Released sources under the
MIT License.
- Interpret TPTP functions and relations in a finite model to guide
clause selection.
- Process TPTP include directives.
- Handle TPTP block comments.
Version 2.2: 18 March 2009
- Accept input problems in TPTP syntax that contain a mix of CNF and
FOF formulas.
- Ported to
Poly/ML.
- Estimate error locations when parsing TPTP problem files.
- Output normalization steps in TSTP format.
Version 2.1: 1 February 2008
- Basic splitting of FOF conjecture formulas.
- Weight clauses using finite models generated from the problem
axioms.
- Output proofs in TSTP format.
Version 2.0: 21 May 2007
- Complete rewrite, dropping from 13,000 to 10,000 lines of code and
using the new Standard ML basis library.
- The only implemented calculus is ordered resolution and ordered
paramodulation, with no sticky ordering constraints.
- Reads in problems in the new TPTP format.
Version 1.5: 14 January 2004
- Scheduling provers is no longer based on time used, but rather
number of inferences.
- Reads problems in TPTP First-Order Formula (FOF) syntax.
- Simplification of resolution clauses using disequation literals.
- Implemented finite models to guide clause selection in resolution.
- The model elimination prover optimizes the order of rules and
literals within rules.
Version 1.4: 2 October 2003
- Added an ordered resolution prover to the default set.
- Improved resolution performance with a special-purpose datatype
for inter-reducing equations.
Version 1.3: 18 June 2003
- Better benchmarking using new MLton source-level profiling.
- Resolution is more robust and efficient, and includes an option
for clauses to inherit ordering constraints.
- Standardized command-line option processing.
Version 1.2: 19 November 2002
- Standalone version created using the
MLton
compiler.
- Ground-up rewrite of resolution, which now performs ordered
resolution and ordered paramodulation.
Version 1.1: 21 September 2002
- Improved model elimination performance with better caching.
- First-order substitutions are now fully Boultonized.
- The logical kernel performs peep-hole optimizations to keep proofs
as small as possible.
Version 1.0: 18 July 2002
- Released sources under version 2 of the GPL License.


PostgreSQL 9.4 - Looking Up (With JSONB and Logical Decoding)
Just a few weeks back I wrote a article discussing many of the things that were likely to miss making the 9.4 PostgreSQL release. Since that post a few weeks ago the landscape has already changed, and much more for the positive.
The lesson here, is never count Postgres out. As Bruce discussed in a recent interview, Postgres is slow and steady, but much like the turtle can win the race.
So onto the actual features:
JSONB
JSON has existed for a while in Postgres. Though the JSON that exists today simply validates that your text is valid JSON, then goes on to store it in a text field. This is fine, but not overly performant. If you do need some flexibility of your schema and performance without much effort then hstore may already work for you today, you can of course read more on this in an old post comparing hstore to json.
But let’s assume you do want JSON and a full document store, which is perfectly reasonable. Your option today is still best with the JSON datatype. And if you’re retrieving full documents this is fine, however if you’re searching/filtering on values within those documents then you need to take advantage of some functional indexing. You can do this some of the built-in operators or with full JS in Postgres. This is a little more work, but also very possible to get good performance.
Finally, onto the perfect world, where JSON isn’t just text in your database. For some time there’s been a discussion around hstore and its future progress and of course the future of JSON in Postgres. These two worlds have finally heavily converged for PostgreSQL 9.4 giving you the best of both worlds. With what was known as hstore2, by The Russians under the covers, and collective efforts on JSONB (Binary representation of JSON) which included all the JSON interfaces you’d expect. We now have full document storage and awesome performance with little effort.
Digging in a little further, why does it matter that its a binary representation? Well under the covers building on the hstore functionality brings along some of the awesome index types in Postgres. Namely GIN and possibly in the future GIST. These indexes will automatically index all keys and values within a document, meaning you don’t have to manually create individual functional indexes. Oh and they’re fast and often small on disk as well.
Logical Decoding
Logical replication was another feature that I talked about that was likely missing. Here there isn’t the same positive news as JSONB, as there’s not a 100% usable feature available. Yet there is a big silver lining in it. Committed just over a week ago was logical decoding. This means that we can decode the WAL (Write-Ahead-Log) into logical changes. In layman’s terms this means something thats unreadable to anything but Postgres (and version dependent in cases) can be intrepretted to a series of INSERT
s, UPDATE
s, DELETE
s, etc. With logical commands you could then start to get closer to cross version upgrades and eventually multi-master.
With this commit it doesn’t mean all the pieces are there in the core of Postgres today. What it does mean is the part thats required of the Postgres core is done. The rest of this, which includes sending the logical replication stream somewhere, and then having something apply it can be developed fully as an extension.
In Conclusion
Postgres 9.4 isn’t 100% complete yet, as the commitfest is still going on. You can follow along on the postgres hackers mailing list or on the commitfest app where you can follow specific patches or even chip in on reviewing. And of course I’ll do my best to continue to highlight useful features here and surface them on Postgres Weekly as well.


A third party service can request user preference and user intent information from the SOCIETIES platform explicitly by using the org.societies.api.personalisation.mgmt.IPersonalisationManager interface. The following two methods allow a 3p service to request a user preference and a user intent action respectively from the Personalisation system.
The requestor parameter defines the identity of the third party service that is requesting the preference information. The Requestor class has a subclass org.societies.api.identity.RequestorService which should be used to instantiate the identity of the third party service. If the requestor parameter is not properly defined, the Personalisation system will not return valid preference information.
The ownerID parameter defines the identity of the user for which the third party service is requesting the information. Currently, as the platform does not support multiple identities, the third party service should utilise the org.societies.api.identity.IIdentityManager.getThisNetworkNode(); to retrieve the identity of the user on the current node as long as the service is running on a user's node.
The serviceType parameter is defined by the third party service developer in the service meta data.
The serviceID parameter is defined by the platform and should be retrieved by calling the method
where the identity parameter is the identity of the CSS that provides the service and callingClass is the class defined in the bean definition of the jar (in bundle-context.xml). The preferenceName parameter is also defined by the third party service developer and it is the service that is able to understand the semantics of this parameter and apply it properly since it was the service that sent this information to the platform using the


Welcome to the Landing Page! Use the Tabs above to find links for each functional area.
Please let the Sysad's know if you would like any functionality added to your functional area's page.