Preparation time
overnight
Cooking time
30 mins to 1 hour
Serves
Serves 8
A million miles away from a kebab shop, try this flavourful feast at home.
For the lemon paste, sterilize a 2-litre/3½-pint airtight container and arrange one layer of the lemon slices in the container, then sprinkle with some of the salt. Repeat this process until all the lemons and salt are used up. Cover with the oils and seal the container. These can be used after three days and kept for up to a week.
To make the paste, strain the lemons from the oil and reserve the oil. Put the lemons in a food processor and add the spices. Blend, adding enough oil as you go to make a paste.
For the kebab, put a large, shallow pan over a medium heat. Add the oil and onion and sweat for 5 minutes. Add the pistachios and pine nuts and sauté for another 5 minutes. Add the garlic and sauté for 3 minutes.
Add both types of mince, in batches, breaking up each batch with a wooden spoon and allowing it to cook for 3–4 minutes before you add the next batch. Increase the heat to high and cook, stirring, for 10–15 minutes. Stir in the spices and lemon paste and season with salt and pepper. Reduce the heat to medium and cook for 5 minutes.
For the tapenade, put all the ingredients except the oil in a blender and blend. Gradually add the oil until you have the right consistency.
For the pesto, put all the ingredients in a blender and blend until combined.
For the tahigurt, mix all the ingredients together in a bowl. Divide between four plates.
Spoon the meat over the tahigurt. Spoon over the toppings and serve with theharissa and pittas.


Freecell Solver version 4.2.0, has been released. It is available in the form of a source archive, from the download page. Freecell Solver is an open source library and some command line applications, for automatically solving several variants of card Solitaire / Patience games, including Freecell.
This release sports the new configuration theme “-l conspiracy-theory” (or “-l ct”) which is somewhat faster than the best contender up to it, “-l amateur-star”, some relatively minor bug fixes, new compile-time options, and many small and somewhat larger code cleanups, refactorings, and optimisations.
“conspiracy-theory” is a reference to the Jewish holiday of Purim, which took place around the time of its release and an old post of mine about it.
Enjoy!


Documentation / Features / L2 Cache
L2 Cache
When we want to talk about caching for performance we are talking about the "Level 2" cache or the "server cache". It is called the "Level 2 cache" because the persistence context is often referred to as the "Level 1 cache".
The goal of the L2 server cache is to gain very significant performance improvement by not having to hit the database. Ebean has 2 types of caches – Bean caches and Query caches.
Bean Caches
Bean caches hold entity beans and are keyed by their Id values. The bean cache can be used with:
- Find by id
- Find one by "natural key"
- Find many by "natural keys"
Query Caches
Query caches hold the results of queries (Lists, Sets, Maps of entity beans and Count) and are keyed by the query hash value (effectively a hash of the query and its bind values). The entries in a query cache are invalidated by ANY change to the underlying table – insert, update or delete. This means that the query cache is only useful on entities that are infrequently modified (typically "lookup tables" such as countries, currencies, status codes etc).
The query cache can be used with:
- Find list/set/map queries
L2/local and L3/remote
L2 cache can thought of as having Near Caches
and Remote Caches
where
a "Near cache" is in the same process as the EbeanServer instance (and does not require a network
access) and a "Remote cache" that requires a network access.
L3 bean cache options
The following are the 3 main approaches when we get a miss on the a local L2 bean cache.
- Use nothing and hit the database
- Use Hazelcast, Apache Ignite or similar data grid/key value store
- Use ElasticSearch
The L2 bean cache is keyed by id value so really anything resembling a key value store (distributed map) works well for bean caching.
Note that ElasticSearch has the advantage that we update it with changes (as deltas to documents) rather than remove/invalidate an entry in a map so with ElasticSearch we are always going to get a hit (and hence always avoid hitting the database). There is also the potential benefit that ElasticSearch documents will often contain denormalisation (embedded documents) so a hit against ElasticSearch will populate more of the graph and avoid extra hits. For example, a hit of an order can populate customer details like customer name.
L3 query cache options
The following are the 2 main approaches when we get a miss on the local L2 query cache.
- Use nothing and hit the database
- Use ElasticSearch
The significant benefit of using ElasticSearch
is that it can address both parts of the L2 cache
meaning that we can use it for L2 query cache
(by translating ORM queries into ElasticSearch queries)
as well as the L2 bean cache
.
We can update ElasticSearch as changes occur and use the performance of inverted indexes to perform very fast queries (avoiding the database hit like L2 query cache but not having the issue of frequent invalidation that L2 query cache suffers from).
ElasticSearch
The current emphasis for Ebean ORM is to utilise ElasticSearch as the best L3 cache option. This means that
Read consistency
With Ebean L2 caching there is no attempt to provide transactional read consistency
ACID/Transactional databases do a lot of things for us and this includes providing "read consistency" based on transaction isolation levels (MVCC databases like Postgres and Oracle emphasis this more).
With Ebean L2 caching there is no attempt to provide transactional read consistency
.
What that means is that if part of your application needs transactional read consistency then
use the database
to do that.
L2 cache works to eventual consistency
Instead with Ebean L2 caching the view is that eventual consistency is good enough, much simpler and a more natural approach when using ElasticSearch. Given what ElasticSearch is doing for us behind the scenes (flush, merge, optimise etc) in order to provide inverted index awesomeness we happily go with eventual consistency and the associated simplicity.
Near cache
With Ebean the view is that the cost of trying to make L2 caching read consistent is not worth it.
Instead we treat the L2 cache as reasonably up to date
. In practical terms this means that
cache invalidation occurs in the background after successful commits. L2 near caches are invalidated across
the cluster very quickly (millisecond) but this is not strictly transactional (there is a delay after the commit).
ElasticSearch
When we use ElasticSearch the delay of a change (insert, update, delete) being visible in ElasticSearch
is going to be longer with a default of 1 second delay
but for various bean types
and use cases we may choose to increase that delay to support more throughput or be more efficient overall.
This is similar to decisions on how frequently database materialised views
should be updated.
Table IUD invalidation (Bulk updates)
Bulk insert, update or delete events are processed by table. For a given table the bean types that depend on that table are determined and then for each bean type the L2 bean cache and L2 query cache are invalidated as necessary.
Cluster message
The message sent around the cluster contains the table name and boolean flags for insert, update and delete.
L2 query cache
Inserts, updates or deletes:
Invalidate the entire L2 query cache for the related bean type
For any bulk statements (bulk table insert, update or delete statement) the entire L2 query cache is invalidated for the associated bean type. For example, a bulk update of the customer table invalidates the entire L2 query cache for the Customer bean type.
L2 bean cache
Inserts:
Do not effect the L2 bean cacheUpdates:
Invalidate the entire L2 bean cache for the related bean typeDeletes:
Invalidate the entire L2 bean cache for the related bean type
Bean IUD invalidation
Persisted beans are processed by bean type and id value.
Cluster message
The message sent around the cluster contains the bean type and 3 lists of ids - a list of id values for inserted, updated and deleted beans.
L2 query cache
Inserts, updates or deletes:
Invalidate the entire L2 query cache for the bean type
For any bean persist event invalidates the entire related L2 query cache for the associated bean type. For example, saving a customer bean invalidates the entire L2 query cache for the Customer bean type.
L2 bean cache
Inserts:
Do not effect the L2 bean cacheUpdates:
An entry is updated with changesDeletes:
An entry is removed from the L2 bean cache based on the id value
External invalidation
When you save/delete beans via Ebean.save() and Ebean.delete() etc Ebean will automatically maintain its cache (removing cached beans and cached queries as appropriate). However, you may often find yourself modifying the database outside of Ebean. (via stored procedures etc)
For example, you could be using other frameworks, your own JDBC code, stored procedures, batch systems etc. When you do so (and you are using Ebean caching) then you can inform Ebean so that it invalidates appropriate parts of its cache.
// inform Ebean that some rows have been inserted and updated
// on the country table.
// ... Ebean will invalidate the appropriate caches
boolean inserts = true;
boolean updates = true;
boolean deletes = false;
Ebean.externalModification("country", inserts, updates, deletes);
Alternative:
ServerCacheManager also provides explicit API for clearing caches.
// clearAll() caches via the ServerCacheManager ...
ServerCacheManager serverCacheManager = ebeanServer.getServerCacheManager();
// Clear all the caches on the default/primary EbeanServer
serverCacheManager.clearAll();
// clear both the bean and query cache
// for Country beans ...
serverCacheManager.clear(Country.class);


WebSockets create a fast, bi-directional connection between your server and a client's web browser.
As of version 1.7, WebSocket support has been moved into a new extension, and the existing hx-ws tag has been deprecated. All future development will occur in the extension code, and the deprecated tag will be removed in htmx version 2.0
| hx-ext | Make sure the WS extension is initialized on every page or page fragment where you use WebSockets. |
| ws-connect | Connects to a WebSocket. All received messages parsed as OOB Swaps. |
| ws-send | Marks a form that, when submitted, will have its contents serialized and sent to the connected WebSocket server |


You can use the group_by on a enumerable object to return a hash on a block. The key becomes the result hash and the value of the key is an array that matches the key. Lets look at an example:
names = ["Matt", "Jen", "James", "Alfred", "John", "Dan", "Mark", "Don"]
puts names.group_by {|name| name.length}
This would return:
{4=>["Matt", "John", "Mark"], 3=>["Jen", "Dan", "Don"], 5=>["James"], 6=>["Alfred"]}
This is an incredibly useful way to quickly make a hash that groups items according to some kind of shared characteristic. I might just go use this on challenge 2.


Reports declarations of classes, methods and fields that reference an unstable API type in the signature,
but are not marked with the same unstable annotation.
This inspection may be useful to check that no unstable (internal, experimental) types are exposed in signatures of public API.
For example, if an experimental class is used as the return type of a method, the method is also considered experimental
because incompatible changes of the type (deletion or move to another package) lead to incompatible method signature changes.
Use the list below to specify the annotations which mark an unstable API.


The Oculus Rift™ was a Kickstarter crowdfunding campaign that was successfully funded toward its goal of $250,000 within just 4 hours of launching. In just 36 hours they had surpassed $1,000,000 finally settling on $2,437,429, leaving the project 974% funded.
The campaign was launched by Palmer Luckey, a technology and virtual reality enthusiast who wanted a VR solution that was both more effective than what is currently on the market and inexpensive for gamers.
Check out the Oculus Rift Kickstarter page here: Oculus Rift: Step Into the Game.
Currently development units are being manufactured and distributed to software developers and early adopters all across the world. The development kits cost $300 and include 4 months of Unity Pro.
More about the Unity game engine can be found here: Unity.


Dataset:
UNDP Adaptation Learning Mechanism
UNFCCC Private Sector Initiative
ClimateWise on Insurance Industry
Ci-Grasp
OECD riomarkers
Climate Funds Update (multi-lateral)
National Adaptation Programs of Action
Combined data set
Sort:
nr of projects
alphabetical
X axis:
Y axis:
Data:
all
Only India and Bangladesh


{% extends "base_template.html" %} {% block main_title %}
In the future, you will be able log in and post to connected social media sites here.


Toggle navigation
FIMK
BETA
Accounts
Contacts
Asset Exchange
Digital Goods Store
Dev Tools
{{alert.url}} says
{{a.msg.split('|')[1]}}
Click to retry..


Approx viral load:
This site is a UI prototype. Please do NOT use it as a source for real scientific / medical / public health advice.
If you happen to be a qualified epidemiologist / public health official / etc. and you'd like to help make this genuinely useful, please get in touch.


--- layout: babyublog title: Baby U Blog subtitle: Building the Next Generation --- {% for post in site.posts %}
{{ post.excerpt }}


--- layout: post authors: ["Aleksandra Pawlik"] title: "Feedback from the First Cambridge R Bootcamp" date: 2014-01-18 time: "08:30:00" tags: ["Bootcamps", "Cambridge University"] ---
The first R Software Carpentry bootcamp in Cambridge took place on January 7 and 8, 2014. Hosted by the Centre for Mathematical Sciences, the bootcamp was organised by two SSI Fellows, Stephen Eglen and Laurent Gatto. There were 24 participants and a long waiting list of those who wanted to learn R, version control and make.
The bootcamp had a broad coverage of using R, from analysing data to building your own packages and sharing them on GitHub. The three modules on programming, packaging and testing were tied together by the usage and examples from the Camweather package. The teaching material for R was based on the material which Laurent and Stephen have developed for the R courses that they run in Cambridge.
Overall the bootcamp received some very positive feedback from the attendees. In the post-bootcamp questionnaire they were asked to say what they learnt that would be useful for them and here is what they said:
I know now how to use R, Git, GitHub and where to look for info. I've seen examples of make and I think I would be able to generate Makefiles with a bit of patience.
Overview of commands and language syntax and how/where to look up additional information for future use. Knowledge on how to setup repository and deal with new versions and perform central updates. Good mix of lecture and hands-on examples. Etherpad was good as it allowed the course to stay on topic.
The idea behind version control and how to implement it in GitHub was a crucial learning for my programming practise from now on. The presenter make it sound very easy and I will definitely start using that not only for version control in codes but also for shared research and writing papers. I will also lean how to create and check packages in R, in a straightforward way demistifying packing creation. Vignettes and markdown will certainly be very useful for future research practice.
There were several challenges that we faced during the bootcamp. The main issue was the pace of teaching which, for the majority was "just right", but for a few attendees turned out to be "too fast" or "too slow". This is a problem that most bootcamps have. In the questionnaire before the bootcamp we asked the participants about their programming experience. All attendees said they have programmed and most of them selected R as their main programming language. Only three said that they write code once a year or less often. But even for that advanced audience there was definitely too much material squeezed into two days and some of the exercises had to be skipped. The good thing is that they are still available online together with solutions.
The shell-on-Windows-issue also came up in Cambridge. One of the attendees was unalble to work with Make on mysysGit (Git Bash). There were also problems with Git. These problems have been known before and it seems that with every new version of Windows, mysysGit and Cygwin, there may be different solutions.
But despite these struggles, the bootcamp was a good start for Software Carpentry in the UK in 2014, and both Stephen and Laurent are keen to run another event in the future.
See also this news item about the Cambridge R bootcamp on the Software Sustainability Institute's website.


Sensex ends 216 points lower; IT stocks fall
NSE Nifty settled 54 points down.
by PTIMarket benchmark Sensex dropped 216 points on Friday, dragged by losses in index-heavyweights Infosys, TCS and HDFC Bank.
After trading on a weak note through the day, the 30-share index ended 215.76 points, or 0.53%, lower at 40,359.41. It hit an intra-day low of 40,276.83 and a high of 40,653.17.
Similarly, the broader NSE Nifty settled 54 points, or 0.45%, down at 11,914.40.
Infosys was the top loser in the Sensex pack, dropping 2.89%, followed by TCS, Asian Paints, Bharti Airtel and HCL Tech.
On the other hand, Tata Steel gained 3.74%, NTPC 2.35%, Vedanta 2.27% and ONGC 2.18%.
IT stocks led the fall in the market amid reports of changes in US work visa requirements aimed at protecting American workers, traders said.
Elsewhere in Asia, bourses in Hong Kong, Tokyo and Seoul settled in the green, while Shanghai finished on a negative note.
European equities were also trading on a positive note in their respective early deals.
Meanwhile, the Indian rupee depreciated marginally to 71.79 against the US dollar in intra-day trade.
Brent crude futures, the global oil benchmark, dipped 0.03% to USD 63.95 per barrel.


History · Log · Pageviews (All languages · Redirects) · Reasonator (Wikidata)
General statistics
Authorship
Top editors
Year counts
Month counts
(Semi-)automated edits
Assessments
General statistics [show] [hide]
| ID | 68186473 |
| Wikidata ID | Q94653118 · 7 sitelinks |
| Page size | 5,642 bytes |
| Total edits | 104 |
| Editors | 52 |
| Assessment | Stub |
| Pageviews (60 days) | 200,354 |
| Minor edits | 18 · (17.3%) |
| IP edits | 46 · (44.2%) |
| Bot edits | 5 · (4.8%) |
| (Semi-)automated edits | 7 |
| Reverted edits | 8 |
| First edit | 2021-07-08 09:51 • GreenZeb • 1,509 |
| Latest edit | 2021-11-13 02:21 • <IP_ADDRESS> • -1 |
| Max. text added | 2021-10-02 00:15 • Grayfell • 1,566 |
| Max. text deleted | 2021-10-08 21:35 • Grayfell • -1,222 |
| Edits | |
| Average time between edits (days) | 1.2 days |
| Average edits per user | 2 |
| Average edits per day | 1 |
| Average edits per month | 24.9 |
| Average edits per year | 104 |
| Edits in the past 24 hours | 0 |
| Edits in the past 7 days | 4 |
| Edits in the past 30 days | 18 |
| Edits in the past 365 days | 104 |
| Edits made by the top 10% of editors | 54 · (51.9%) |
| Links | |
| Links to this page | 23 |
| Redirects | 0 |
| Links from this page | 144 |
| External links | 9 |
| Categories | 12 |
| Files | 3 |
| Templates | 71 |
| Prose | |
| Characters | 2,004 |
| Words | 321 |
| Sections | 3 |
| References | 12 |
| Unique references | 9 |
Accounts
·
58 (55.8%)
IPs
·
46 (44.2%)
Major edits
·
86 (82.7%)
Minor edits
·
18 (17.3%)
Top 10%
·
54 (51.9%)
Bottom 90%
·
50 (48.1%)
Authorship
[show]
[hide]
Powered by Wikiwho
Loading...
Top editors
[show]
[hide]
Editor statistics over the history of the article.
Top 10 by edits
Grayfell
·
15 (27.8%)
Ayofamalam123
·
6 (11.1%)
Jamesluiz102
·
5 (9.3%)
2A02:2455:465:9600:784A:3D2:A720:95FA
·
5 (9.3%)
2A02:C7F:3464:A900:D1D7:2E31:683D:B717
·
5 (9.3%)
<IP_ADDRESS>
·
5 (9.3%)
<IP_ADDRESS>
·
4 (7.4%)
<IP_ADDRESS>
·
3 (5.6%)
Phediuk
·
3 (5.6%)
GreenZeb
·
3 (5.6%)
Top 10 by added text
(approximate)
Grayfell
·
2,504 (29.2%)
GreenZeb
·
1,509 (17.6%)
Changeanew
·
1,378 (16.1%)
Jamesluiz102
·
832 (9.7%)
<IP_ADDRESS>
·
576 (6.7%)
Ayofamalam123
·
428 (5%)
2A02:2455:465:9600:784A:3D2:A720:95FA
·
402 (4.7%)
<IP_ADDRESS>
·
379 (4.4%)
<IP_ADDRESS>
·
336 (3.9%)
Phediuk
·
226 (2.6%)
1 Average time between edits (days)
2 Added text is any positive addition that wasn't reverted
2 Added text is any positive addition that wasn't reverted
Bot list
| Rank | Bot | Links | Edits |
|---|---|---|---|
| 1 | Citation bot | Top Edits · Edit Counter | 2 |
| 2 | FrescoBot | Top Edits · Edit Counter | 1 |
| 3 | ClueBot NG | Top Edits · Edit Counter | 1 |
| 4 | WikiCleanerBot | Top Edits · Edit Counter | 1 |
All data is approximate.
Year counts [show] [hide]
All edits
Minor edits
IP edits
Size
| Year | Edits | IPs | IPs % | Minor edits | Minor edits % | Log events |
|---|---|---|---|---|---|---|
| 2021 | 104 | 46 | 44.2% | 18 | 17.3% | 1 deletion |
Month counts [show] [hide]
(Semi-)automated edits [show] [hide]
| Tool | Edits |
|---|---|
| Page curation | 1 |
| Huggle | 1 |
| RedWarn | 1 |
| Undo | 1 |
| Generic rollback | 1 |
| reFill | 1 |
| Bot revert | 1 |
Assessments [show] [hide]
| WikiProject | Assessment | Importance |
|---|---|---|
| Video games | Stub | Low |
All times are in UTC.


Friend Finder
Answer a few basic questions.
Then meet your new Bestie!
Go to Survey
API Friends List


My name is Arianna. I was born and raised in Portland, Oregon. I am currently a student at Epicodus in the design track on my way to becoming a front end developer. When I'm not coding, I'm loving on my dogs, playing video games or just spending time outside.
I had trouble figuring out what I wanted to be, the kind of person I wanted to be in life. I battled different ideas for a long time, and I knew I couldn't just settle for anything. I wanted to do more, I wanted to be more. I wanted to make a difference in others' lives.
I picked software developing because I thrive off of helping solve people's problems. I like to help, I like to be available when people need me. I felt as if this field was a great way to leave my print on the world as well as connect with others.


public class DataFrameReader
extends Object
implements org.apache.spark.internal.Logging
Dataset
from external storage systems (e.g. file systems,
key-value stores, etc). Use SparkSession.read
to access this.
| Modifier and Type | Method and Description |
|---|---|
Dataset<Row> |
csv(Dataset<String> csvDataset)
Loads an
Dataset[String] storing CSV rows and returns the result as a DataFrame . |
Dataset<Row> |
csv(scala.collection.Seq<String> paths)
Loads CSV files and returns the result as a
DataFrame . |
Dataset<Row> |
csv(String... paths)
Loads CSV files and returns the result as a
DataFrame . |
Dataset<Row> |
csv(String path)
Loads a CSV file and returns the result as a
DataFrame . |
DataFrameReader |
format(String source)
Specifies the input data source format.
|
Dataset<Row> |
jdbc(String url,
String table,
java.util.Properties properties)
Construct a
DataFrame representing the database table accessible via JDBC URL
url named table and connection properties. |
Dataset<Row> |
jdbc(String url,
String table,
String[] predicates,
java.util.Properties connectionProperties)
Construct a
DataFrame representing the database table accessible via JDBC URL
url named table using connection properties. |
Dataset<Row> |
jdbc(String url,
String table,
String columnName,
long lowerBound,
long upperBound,
int numPartitions,
java.util.Properties connectionProperties)
Construct a
DataFrame representing the database table accessible via JDBC URL
url named table. |
Dataset<Row> |
json(Dataset<String> jsonDataset)
Loads a
Dataset[String] storing JSON objects (JSON Lines
text format or newline-delimited JSON) and returns the result as a DataFrame . |
Dataset<Row> |
json(JavaRDD<String> jsonRDD)
Deprecated.
Use json(Dataset[String]) instead. Since 2.2.0.
|
Dataset<Row> |
json(RDD<String> jsonRDD)
Deprecated.
Use json(Dataset[String]) instead. Since 2.2.0.
|
Dataset<Row> |
json(scala.collection.Seq<String> paths)
Loads JSON files and returns the results as a
DataFrame . |
Dataset<Row> |
json(String... paths)
Loads JSON files and returns the results as a
DataFrame . |
Dataset<Row> |
json(String path)
Loads a JSON file and returns the results as a
DataFrame . |
Dataset<Row> |
load()
Loads input in as a
DataFrame , for data sources that don't require a path (e.g. |
Dataset<Row> |
load(scala.collection.Seq<String> paths)
Loads input in as a
DataFrame , for data sources that support multiple paths. |
Dataset<Row> |
load(String... paths)
Loads input in as a
DataFrame , for data sources that support multiple paths. |
Dataset<Row> |
load(String path)
Loads input in as a
DataFrame , for data sources that require a path (e.g. |
DataFrameReader |
option(String key,
boolean value)
Adds an input option for the underlying data source.
|
DataFrameReader |
option(String key,
double value)
Adds an input option for the underlying data source.
|
DataFrameReader |
option(String key,
long value)
Adds an input option for the underlying data source.
|
DataFrameReader |
option(String key,
String value)
Adds an input option for the underlying data source.
|
DataFrameReader |
options(scala.collection.Map<String,String> options)
(Scala-specific) Adds input options for the underlying data source.
|
DataFrameReader |
options(java.util.Map<String,String> options)
Adds input options for the underlying data source.
|
Dataset<Row> |
orc(scala.collection.Seq<String> paths)
Loads ORC files and returns the result as a
DataFrame . |
Dataset<Row> |
orc(String... paths)
Loads ORC files and returns the result as a
DataFrame . |
Dataset<Row> |
orc(String path)
Loads an ORC file and returns the result as a
DataFrame . |
Dataset<Row> |
parquet(scala.collection.Seq<String> paths)
Loads a Parquet file, returning the result as a
DataFrame . |
Dataset<Row> |
parquet(String... paths)
Loads a Parquet file, returning the result as a
DataFrame . |
Dataset<Row> |
parquet(String path)
Loads a Parquet file, returning the result as a
DataFrame . |
DataFrameReader |
schema(String schemaString)
Specifies the schema by using the input DDL-formatted string.
|
DataFrameReader |
schema(StructType schema)
Specifies the input schema.
|
Dataset<Row> |
table(String tableName)
Returns the specified table/view as a
DataFrame . |
Dataset<Row> |
text(scala.collection.Seq<String> paths)
Loads text files and returns a
DataFrame whose schema starts with a string column named
"value", and followed by partitioned columns if there are any. |
Dataset<Row> |
text(String... paths)
Loads text files and returns a
DataFrame whose schema starts with a string column named
"value", and followed by partitioned columns if there are any. |
Dataset<Row> |
text(String path)
Loads text files and returns a
DataFrame whose schema starts with a string column named
"value", and followed by partitioned columns if there are any. |
Dataset<String> |
textFile(scala.collection.Seq<String> paths)
Loads text files and returns a
Dataset of String. |
Dataset<String> |
textFile(String... paths)
Loads text files and returns a
Dataset of String. |
Dataset<String> |
textFile(String path)
Loads text files and returns a
Dataset of String. |
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
$init$, initializeForcefully, initializeLogIfNecessary, initializeLogIfNecessary, initializeLogIfNecessary$default$2, initLock, isTraceEnabled, log, logDebug, logDebug, logError, logError, logInfo, logInfo, logName, logTrace, logTrace, logWarning, logWarning, org$apache$spark$internal$Logging$$log__$eq, org$apache$spark$internal$Logging$$log_, uninitialize
public Dataset<Row> csv(String... paths)
DataFrame
.
This function will go through the input once to determine the input schema if inferSchema
is enabled. To avoid going through the entire data once, disable inferSchema
option or
specify the schema explicitly using schema
.
You can find the CSV-specific options for reading CSV files in Data Source Option in the version you use.
paths
- (undocumented)public Dataset<Row> csv(String path)
DataFrame
. See the documentation on the
other overloaded csv()
method for more details.
path
- (undocumented)public Dataset<Row> csv(Dataset<String> csvDataset)
Dataset[String]
storing CSV rows and returns the result as a DataFrame
.
If the schema is not specified using schema
function and inferSchema
option is enabled,
this function goes through the input once to determine the input schema.
If the schema is not specified using schema
function and inferSchema
option is disabled,
it determines the columns as string types and it reads only the first line to determine the
names and the number of fields.
If the enforceSchema is set to false
, only the CSV header in the first line is checked
to conform specified or inferred schema.
csvDataset
- input Dataset with one CSV row per recordheader
option is set to true
when calling this API, all lines same with
the header will be removed if exists.
public Dataset<Row> csv(scala.collection.Seq<String> paths)
DataFrame
.
This function will go through the input once to determine the input schema if inferSchema
is enabled. To avoid going through the entire data once, disable inferSchema
option or
specify the schema explicitly using schema
.
You can find the CSV-specific options for reading CSV files in Data Source Option in the version you use.
paths
- (undocumented)public DataFrameReader format(String source)
source
- (undocumented)public Dataset<Row> jdbc(String url, String table, java.util.Properties properties)
DataFrame
representing the database table accessible via JDBC URL
url named table and connection properties.
You can find the JDBC-specific option and parameter documentation for reading tables via JDBC in Data Source Option in the version you use.
url
- (undocumented)table
- (undocumented)properties
- (undocumented)public Dataset<Row> jdbc(String url, String table, String columnName, long lowerBound, long upperBound, int numPartitions, java.util.Properties connectionProperties)
DataFrame
representing the database table accessible via JDBC URL
url named table. Partitions of the table will be retrieved in parallel based on the parameters
passed to this function.
Don't create too many partitions in parallel on a large cluster; otherwise Spark might crash your external database systems.
You can find the JDBC-specific option and parameter documentation for reading tables via JDBC in Data Source Option in the version you use.
table
- Name of the table in the external database.columnName
- Alias of partitionColumn
option. Refer to partitionColumn
in
Data Source Option in the version you use.connectionProperties
- JDBC database connection arguments, a list of arbitrary string
tag/value. Normally at least a "user" and "password" property
should be included. "fetchsize" can be used to control the
number of rows per fetch and "queryTimeout" can be used to wait
for a Statement object to execute to the given number of seconds.url
- (undocumented)lowerBound
- (undocumented)upperBound
- (undocumented)numPartitions
- (undocumented)public Dataset<Row> jdbc(String url, String table, String[] predicates, java.util.Properties connectionProperties)
DataFrame
representing the database table accessible via JDBC URL
url named table using connection properties. The predicates
parameter gives a list
expressions suitable for inclusion in WHERE clauses; each one defines one partition
of the DataFrame
.
Don't create too many partitions in parallel on a large cluster; otherwise Spark might crash your external database systems.
You can find the JDBC-specific option and parameter documentation for reading tables via JDBC in Data Source Option in the version you use.
table
- Name of the table in the external database.predicates
- Condition in the where clause for each partition.connectionProperties
- JDBC database connection arguments, a list of arbitrary string
tag/value. Normally at least a "user" and "password" property
should be included. "fetchsize" can be used to control the
number of rows per fetch.url
- (undocumented)public Dataset<Row> json(String... paths)
DataFrame
.
JSON Lines (newline-delimited JSON) is supported by
default. For JSON (one record per file), set the multiLine
option to true.
This function goes through the input once to determine the input schema. If you know the schema in advance, use the version that specifies the schema to avoid the extra scan.
You can find the JSON-specific options for reading JSON files in Data Source Option in the version you use.
paths
- (undocumented)public Dataset<Row> json(String path)
DataFrame
.
See the documentation on the overloaded json()
method with varargs for more details.
path
- (undocumented)public Dataset<Row> json(scala.collection.Seq<String> paths)
DataFrame
.
JSON Lines (newline-delimited JSON) is supported by
default. For JSON (one record per file), set the multiLine
option to true.
This function goes through the input once to determine the input schema. If you know the schema in advance, use the version that specifies the schema to avoid the extra scan.
You can find the JSON-specific options for reading JSON files in Data Source Option in the version you use.
paths
- (undocumented)public Dataset<Row> json(JavaRDD<String> jsonRDD)
JavaRDD[String]
storing JSON objects (JSON
Lines text format or newline-delimited JSON) and returns the result as
a DataFrame
.
Unless the schema is specified using schema
function, this function goes through the
input once to determine the input schema.
jsonRDD
- input RDD with one JSON object per recordpublic Dataset<Row> json(RDD<String> jsonRDD)
RDD[String]
storing JSON objects (JSON Lines
text format or newline-delimited JSON) and returns the result as a DataFrame
.
Unless the schema is specified using schema
function, this function goes through the
input once to determine the input schema.
jsonRDD
- input RDD with one JSON object per recordpublic Dataset<Row> json(Dataset<String> jsonDataset)
Dataset[String]
storing JSON objects (JSON Lines
text format or newline-delimited JSON) and returns the result as a DataFrame
.
Unless the schema is specified using schema
function, this function goes through the
input once to determine the input schema.
jsonDataset
- input Dataset with one JSON object per recordpublic Dataset<Row> load(String... paths)
DataFrame
, for data sources that support multiple paths.
Only works if the source is a HadoopFsRelationProvider.
paths
- (undocumented)public Dataset<Row> load()
DataFrame
, for data sources that don't require a path (e.g. external
key-value stores).
public Dataset<Row> load(String path)
DataFrame
, for data sources that require a path (e.g. data backed by
a local or distributed file system).
path
- (undocumented)public Dataset<Row> load(scala.collection.Seq<String> paths)
DataFrame
, for data sources that support multiple paths.
Only works if the source is a HadoopFsRelationProvider.
paths
- (undocumented)public DataFrameReader option(String key, String value)
All options are maintained in a case-insensitive way in terms of key names. If a new option has the same key case-insensitively, it will override the existing option.
key
- (undocumented)value
- (undocumented)public DataFrameReader option(String key, boolean value)
All options are maintained in a case-insensitive way in terms of key names. If a new option has the same key case-insensitively, it will override the existing option.
key
- (undocumented)value
- (undocumented)public DataFrameReader option(String key, long value)
All options are maintained in a case-insensitive way in terms of key names. If a new option has the same key case-insensitively, it will override the existing option.
key
- (undocumented)value
- (undocumented)public DataFrameReader option(String key, double value)
All options are maintained in a case-insensitive way in terms of key names. If a new option has the same key case-insensitively, it will override the existing option.
key
- (undocumented)value
- (undocumented)public DataFrameReader options(scala.collection.Map<String,String> options)
All options are maintained in a case-insensitive way in terms of key names. If a new option has the same key case-insensitively, it will override the existing option.
options
- (undocumented)public DataFrameReader options(java.util.Map<String,String> options)
All options are maintained in a case-insensitive way in terms of key names. If a new option has the same key case-insensitively, it will override the existing option.
options
- (undocumented)public Dataset<Row> orc(String... paths)
DataFrame
.
ORC-specific option(s) for reading ORC files can be found in Data Source Option in the version you use.
paths
- input pathspublic Dataset<Row> orc(String path)
DataFrame
.
path
- input pathpublic Dataset<Row> orc(scala.collection.Seq<String> paths)
DataFrame
.
ORC-specific option(s) for reading ORC files can be found in Data Source Option in the version you use.
paths
- input pathspublic Dataset<Row> parquet(String... paths)
DataFrame
.
Parquet-specific option(s) for reading Parquet files can be found in Data Source Option in the version you use.
paths
- (undocumented)public Dataset<Row> parquet(String path)
DataFrame
. See the documentation
on the other overloaded parquet()
method for more details.
path
- (undocumented)public Dataset<Row> parquet(scala.collection.Seq<String> paths)
DataFrame
.
Parquet-specific option(s) for reading Parquet files can be found in Data Source Option in the version you use.
paths
- (undocumented)public DataFrameReader schema(StructType schema)
schema
- (undocumented)public DataFrameReader schema(String schemaString)
spark.read.schema("a INT, b STRING, c DOUBLE").csv("test.csv")
schemaString
- (undocumented)public Dataset<Row> table(String tableName)
DataFrame
. If it's a table, it must support batch
reading and the returned DataFrame is the batch scan query plan of this table. If it's a view,
the returned DataFrame is simply the query plan of the view, which can either be a batch or
streaming query plan.
tableName
- is either a qualified or unqualified name that designates a table or view.
If a database is specified, it identifies the table/view from the database.
Otherwise, it first attempts to find a temporary view with the given name
and then match the table/view from the current database.
Note that, the global temporary view database is also valid here.public Dataset<Row> text(String... paths)
DataFrame
whose schema starts with a string column named
"value", and followed by partitioned columns if there are any.
The text files must be encoded as UTF-8.
By default, each line in the text files is a new row in the resulting DataFrame. For example:
// Scala:
spark.read.text("/path/to/spark/README.md")
// Java:
spark.read().text("/path/to/spark/README.md")
You can find the text-specific options for reading text files in Data Source Option in the version you use.
paths
- input pathspublic Dataset<Row> text(String path)
DataFrame
whose schema starts with a string column named
"value", and followed by partitioned columns if there are any. See the documentation on
the other overloaded text()
method for more details.
path
- (undocumented)public Dataset<Row> text(scala.collection.Seq<String> paths)
DataFrame
whose schema starts with a string column named
"value", and followed by partitioned columns if there are any.
The text files must be encoded as UTF-8.
By default, each line in the text files is a new row in the resulting DataFrame. For example:
// Scala:
spark.read.text("/path/to/spark/README.md")
// Java:
spark.read().text("/path/to/spark/README.md")
You can find the text-specific options for reading text files in Data Source Option in the version you use.
paths
- input pathspublic Dataset<String> textFile(String... paths)
Dataset
of String. The underlying schema of the Dataset
contains a single string column named "value".
The text files must be encoded as UTF-8.
If the directory structure of the text files contains partitioning information, those are
ignored in the resulting Dataset. To include partitioning information as columns, use text
.
By default, each line in the text files is a new row in the resulting DataFrame. For example:
// Scala:
spark.read.textFile("/path/to/spark/README.md")
// Java:
spark.read().textFile("/path/to/spark/README.md")
You can set the text-specific options as specified in DataFrameReader.text
.
paths
- input pathpublic Dataset<String> textFile(String path)
Dataset
of String. See the documentation on the
other overloaded textFile()
method for more details.path
- (undocumented)public Dataset<String> textFile(scala.collection.Seq<String> paths)
Dataset
of String. The underlying schema of the Dataset
contains a single string column named "value".
The text files must be encoded as UTF-8.
If the directory structure of the text files contains partitioning information, those are
ignored in the resulting Dataset. To include partitioning information as columns, use text
.
By default, each line in the text files is a new row in the resulting DataFrame. For example:
// Scala:
spark.read.textFile("/path/to/spark/README.md")
// Java:
spark.read().textFile("/path/to/spark/README.md")
You can set the text-specific options as specified in DataFrameReader.text
.
paths
- input path


---
layout: post
title: 3/20 progress
date: '2014-03-20T23:30:00.000-06:00'
author: Jacob .
tags:
- progress-reports
modified_time: '2014-03-20T23:30:27.260-06:00'
blogger_id: tag:blogger.com,1999:blog-6400085873105072120.post-2467506894542600757
blogger_orig_url: http://www.svlark.com/2014/03/320-progress.html
---
We had a great plotting session this evening.
We nailed down our packing strategy: 15 boxes. We were honestly hoping for a bit less, but we'll get there.
Next steps on the Tanton are insurance, slip rent, and NADA valuation. Are we really trying to buy it? Dunno. We really like it, and this is a worthwhile exercise to learn how this process works. If it all falls into place, I think it could be a great boat for us.
It's time to get serious about the work situation. So yeah, that's up next.


Spatio Temporal Resource Search
Select a origin location
Enter TimeStamp:
HH
MM
SS
Enter Date:
Date
Month
Year
Select an algorithm:
BaseLine
Deterministic
Probabilistic


© 2018 Copyright: An open-source initiative. Made with by CODROP.IO
Customer Category |
|
Number of Units |
|
Your Bill |
|
| Total Units Charge | LKR |
| Fuel Adjustment Charge | LKR |
| Fixed Charge | LKR |
| Grand Total | LKR |


This week I'm reviewing and evaluating the accessibility metrics and features of a chosen site, using a number of testing tools as well as manual a manual review. I have chosen to review Seattle's official travel and tourism site, Visit Seattle. The Visit Seattle web page has a large and wide audience, and it is important for the site to be accessible to multiple impairments
As James Byrd explained, in the Fullstack Academy video on Web Accessibility Guidelines "The web is a lot like a public library, it's a giant store of information available to everyone that people from all over can go to. But if you can't walk up the stairs, you'll have a bit of problem unless they've supplied an access ramp."
The Basics
Let's start with some basics. Knowing that you do not want to exclude visitors to your site with visual, hearing, learning and physical impairments is a good place to start. There are a number of resources that a developer can access to learn how to build a site with the appropriate accessibility features that address multiple issues. The W3 Web Content Accessibility Guidelines (WCAG) are a great place to start.
Some agreed upon basics include:
- Adding alt text to all images, which helps screen readers
- Organizing and assigning header tags in order
- Adding label tags to form fields
- Use high contrast colors between text and background
Now let's see how my chosen site fared.
Site Analysis
Aside from a manual review of the Visit Seattle page, I used two accessibility auditing tools to help with assessing the general accessibility of my chosen page. The tools I used were Google's Lighthouse Accessibility Audit technology available through Chrome DevTools and WebAim's Wave Web Accessibility Evaluation Tool.
My initial manual review of the page found it easy on the eyes, the navigation was displayed with high contrast large clear font, there didn't seem too many moving/overlapping parts that can cause usability and accessibility issues. The page had a good amount of white space and the font used from headings to descriptions is mostly black on white, clean and bright visually. I did notice though that it was somewhat difficult to read some of the headlines that show up on top of the images through out the page and that there are a few places like the image credits where the font size is very small and the color contrast is poor but this was generally on photo credits. In general, to the naked eye the site looks like a model page, easy to use and visually appealing.
Upon opening the Chrome DevTools and running the Lighthouse audit I found that the page contained many more issues and actually had a fairly low accessibility score of 52. The tool listed out the specific issues/opportunities that affected the accessibility score. Each one opened up on to show the specific elements with the mentioned error and the detail on how to fix the issue. Here were the seven issues highlighted:
- Buttons do not have an accessible name
- Frame or iframe elements do not have a title
- Image elements do not have [alt] attributes
- Form elements do not have associated labels
- Links do not have a discernible name
- Background and foreground colors do not have a sufficient contrast ratio
- Some elements have a [tabindex] value greater than 0
The Wave tool also showed that the page had multiple serious accessibility issues and allowed for a thorough review of the page with and without styles and all the areas where contrast was an issue. The wave tool had some very handy features that explained the errors by "what it means, why it matters, how to fix it and a direct link to the guidelines being overlooked. The Wave tool pointed out 55 high alert errors and 46 Contrast errors. Below is a screen shot of the it's accessibility summary and user interface.
Summary
In summary, these accessibility tools helped identify multiple serious development misses pertaining to basic accessibility guidelines. Some simple improvements that could be made would be adding alt attribute descriptions, adding labels to the form inputs and adding a gradient film to help with the number of contrast issues on images with text.


112r
Old English
Modern English
huniges. Do þæt se wæta mæge furþum ofer yrnan þa wyrta. Læt standan .vii. niht and wreoh mid brede. Aseoh þurh clænne claþ ðone drenc. Do eft on þæt ilce fæt. Nytta swa þe þearf sie.
honey. Do [it] so that the liquid may indeed cover the herbs. Let stand seven nights and cover with a board. Strain the drink through a clean cloth. Afterwards, put [it] into the same cup. Use as needed.
Se mon se him gedeþ ymb .xxx. nihta foxes gelyndes dæl on þa eagan, he biþ ece hal.
The person who puts a portion of fox grease on the eyes for about thirty nights, he always will be whole.
Gif mist sie fore eagum: nim cildes hlond and huniges tear meng tosomne begea emfela. Smire mid þa eagan innan. Eft, hrefnes geallan and leaxes and eles and feld beon hunig meng tosomne. Smire mid þære sealfe innan þa eagan.
If darkness is before the eyes: take the urine of a child and a tear-like drop of honey. Mix them both together equally. Smear into the eyes with [it]
22. Afterwards, mix together the gall of a crab and the gall of a salmon and the gall of a lamprey and field bee honey. Smear inside the eyes with that salve.
Wiþ flie: gebærned sealt and swegles æppel and attrum ealra emfela gnid to duste and do on þa eagan. Þweah leohtlice mid wylle wætre and smire æfter mid wifes meolce.
For the white speck: grind burned salt and
beetle nut and attrum to dust, all equally, and put [it] on the eyes. Wash lightly with boiling water and smear afterwards with the milk of a woman.
Gif wyrmas sien on eagum: scearpa þa bræwas innan. Do on þa scearpan celeþonian seap. Þa wyrmas bioþ deade and þa eagan hale.
If worms are in the eyes: scarify the inside of the eyelids. Put the sap of
celandine on the scarification. The worms will be dead and the eyes whole.
Gif flæsc on eagum weaxe: wring wyrmwyrte on þa eagan oþþæt him sel sie.
If flesh grows on the eyes: [put] a press of
wormwort on the eyes until he is well.
Gif on eagan weaxen reade sponge: drype on hat culfran blod oþþe swealwan oððe wifes meoluc oþþæt þa sponge aweg synd.

Gif eagan tyren: nim drige rudan and huniges tear. Meng tosomne. Læt standan .iii. niht. Awring þurh þicne clað linenne
If the eyes tear: take dry
mountain rue and a tear-like drop of honey. Mix together. Let stand three nights. Wring through thick linen cloth


IMBD
Following
Followers
Log Out
Movie Search
Search for a movie
Title
the year rel + genre
plot
actors
directors
Rate this movie and drop a review!
Rate:
Review:
Submit
Movie Rating:
Reviews:


Both domains¶
This proves that we can document both Python and OCaml elements in the same document.
Definitions¶
-
module
M
: sig¶ This is an OCaml module named M.
- end
This is a Python module named M.
This is a Python module named S in module M.
-
M.S.
v
¶ This is a Python data named v in module M.S.
References¶
We can link to modules: M
and M
.
We can link to sub-modules: M.S
and M.S
.
We can link to fully qualified values: M.S.v
and M.S.v
.
We can link to fully qualified values with explicit titles: vv
and vv
.
We can link to fully qualified values and strip their qualifications: v
and v
.
We can link to non-qualified values: v
and v
.
We can link to non-qualified values with explicit titles: vv
and vv
.
We can link to partially qualified values: S.v
and S.v
.
We can link to partially qualified values with explicit titles: vv
and vv
.
We can link to partially qualified values and strip their qualifications: v
and v
.
We can refer to OCaml as default domain: M.S.v
.
We can refer to Python as default domain: M.S.v
.


About ImpactView
ImpactView Philadelphia is a powerful online resource to support a better understanding of Philadelphia’s nonprofit ecosystem. ImpactView Philadelphia helps nonprofit organizations, philanthropies, and community leaders identify needs and opportunities, explore areas of collaboration, and develop programs and services based on measures of community health.
ImpactView Philadelphia visualizes important data on nonprofit organizations combined with individual and household data in an intuitive and user-friendly format.
About the data
ImpactView Philadelphia uses publicly available data on nonprofit organizations through the Internal Revenue Service’s new machine-readable data portal and Business Master File comprising more than 2,300 nonprofit organizations within the city limits. This data is combined with the most recent American Community Survey data released by the U.S. Census Bureau, which is updated annually and provides detailed information at the census tract level. These data sources are combined into a mapping and visualization interface that is free, public, and easy to use.
About the Creators
ImpactView Philadelphia is a project of Drexel University’s graduate Arts Administration program. The project is led by professor and research director Neville Vakharia. ImpactView Philadelphia was supported by a Digital Impact Grant from the Stanford Center for Philanthropy and Civil Society, funded by the Bill and Melinda Gates Foundation. Software development by Azavea.


The first thing you see when you start the Toolbox for the first time is the Welcome View. If you are new to the Toolbox, you should read the Using Help and Managing Views help pages. If you're new to TLA+, try opening an example specification in the Toolbox by clicking on one of the the buttons at the bottom of the Welcome Page.
From the welcome view, you will usually open a specification. See the Managing Your Specifications page. You can also set the Toolbox Preferences.
For further information about TLA+ and the TLA+ tools, see the TLA+ Resources help page.
Your specs should not contain tab characters. See the General section of the Preferences help page.
Important: The In
Case of Trouble help page tells you what to do if you encounter a
Toolbox bug.
In the unlikely event that a bug prevents you from reading the help pages,
these pages are available on the Web
at http://tla.msr-inria.inria.fr/tlatoolbox/doc/contents.html
.
Bookmark this URL in your browser for emergency use.


This feature is currently under construction for this platform.
If you would like to get involved in this work, please check out our community contribution page.
aerogear.org/community/#guides


This tool allows to compare two CSV files, and visualize the diff.
Copy and paste, drag and drop your CSV files or directly type in the editors above,
and they will be automatically compared!
You can also click on "load CSV from URL" button to load your file from a URL.
You can also click on "Browse CSV file" button to load your CSV from a local file.
You can select the separator, the quote and the escape characters to use for CSV files:
You can also directly compare two CSV files by specifying their urls in the GET parameters url1 and url2.
Example: ./index.html?url1=https://extendsclass.com/mock/rest/3b3aea6de65f5bd7576a1079bf9b6ec5/sample1.csv&url2=https://extendsclass.com/mock/rest/3b3aea6de65f5bd7576a1079bf9b6ec5/sample2.csv
This tool highlights in red color the data which are different.


|
Blue Alliance
|
Match |
Gold Alliance
|
|---|---|---|
Total Points |
||
|
Autonomous
|
||
|
Normal
|
||
|
Permanent Goals
|
||
|
Bonus
|
||
|
Penalties
|


If you are a pregnant teen or a teen parent and you don’t have enough money to pay for your baby’s needs or medical care, there are many government programs that will help. You and your baby may be able to get benefits such as:


--- layout: default class: home name: About title: About description: Is it possible to feel successful and satisfied? ---
Have you ever wondered:
to interview artists who we think are passionate to find out how or if they feel satisified.
I’m never satisfied, but I want to believe in a world where hard workers and good artists can sleep at night without their passion as their pillow.
I've always worried that to be "successful," you have to be obsessed and lead an unbalanced life.
*fart*


{{- partial "head.html" . -}}
{{- partialCached "header.html" . -}} {{- block "main" . }}{{- end }} {{- partialCached "footer.html" . -}} {{- partialCached "script.html" . -}}


Our workbooks Computer-Deutsch 1 and 2 help you
to get familiar with those strange words like
"Drucker", "Zwischenablage", "Übertragungsgeschwindigkeit", etc. ö


Project Summary:
This project looked at methods for identifying signal in customer loyalty using previous
transaction histories. This model would be capable of improving customer and company relations
by identifying which customers would be the most promising for potential campaigns and sales.
The project started as a kaggle competition, but was later altered to provide more useful predictions.
Dataset:
The dataset consists largely of past customer transactions and credit card features. It is available publically
here. Each customer had at least three months of transaction histories provided. These were broken down further into historical purchases and purchases at newer merchants. Identifying characteristic differences between how a customer made purchases at historical merchants and how they made purchases at new merchants were incredibly benificial to model performance.
The Solution
Though the project was largely centered around the competition, the final model differs slightly from the model used for the competition. The main differences come from how "outliers" are evaluated.
Identifying the Proper Loss Function:
The competion used a RMSE to evaluate model performance. However this lead to scores being heavily bias by just a few "outlier" samples. These outlier samples can be seen as the spike in target values at -33 in the below figure:
Squaring the error for these outliers causes almost 50% of the total RMSE to come from just over 1% of the samples:
In order to reduce the bias towards these outliers a Huber loss function was used which evaluated larger loss values linearly. This lead to a higher overall RMSE (worse competition results),
but a better overall model (closer predicitons 99% of the time). This highlights a major problem that can arise when a model is evaluated based on an arbitrary metric as opposed to acual utility and should be a cautionary example for future competitions.
Key Metrics
A customers transaction history provides a wealth of information however extracting this information isn't always intuitive.
Identifying key metrics based on transaction aggregations greatly improved the models performance.
These aggregations helped the model extrapolate information such as: when customers make their purchases (day,week,month) and
what the customer purchases (cost, frequency, new vs historical merchants).
Model Selection
The main model leveraged in this project was the LightGBM algorithm. This algorithm allowed for quick training
and metric experimentation as well as producing the best overall validation scores.
The final model was an ensemble of LightGBM models with Huber Regression as well as an ensemble of models training specifically to target customer outliers.
A list of features as well as plots of their respective importance is summarized in the figure below:
Results
The final model used in the kaggle competition placed 108th out of over 4000 entires (Top 3%).
As stated however this model was considered "worse" in practice than the huber regression models used for the final demo. This final model outperformed the competition model almost 99% of the time.


Database of 1.2 Billion Records Found With Scraped Data
by Andrew OrrA database filled with 1.2 billion records of data was found on the dark web back in October. I hesitate to call this a data breach because:
While the collection is impressive for its sheer volume, the data doesn’t include sensitive information like passwords, credit card numbers, or Social Security numbers. It does, though, contain profiles of hundreds of millions of people that include home and cell phone numbers, associated social media profiles like Facebook, Twitter, LinkedIn, and Github, work histories seemingly scraped from LinkedIn, almost 50 million unique phone numbers, and 622 million unique email addresses.
In other words this is all data that people have willingly put on their social media profiles. While it can be used for nefarious purposes (especially phone numbers) this is less of a breach and more of a database of scrapes. Nevertheless I’m using our “data breach” tag.
Check It Out: Database of 1.2 Billion Records Found With Scraped Data


My name is Silé Kiman, and I'm a passionate IT professional who specializes in Custom Web Design and Software application Testing. In my spare time I love to travel, meet new people, and learn about new tools and technologies.
Professional background:
For the past ten years I have worked as a Software Analyst/Engineer.
I also have experience in creating customized websites for clients using WordPress,
and different APIs to meets their various needs. I have several years of experience
working with waterfall and agile methodologies, as well as a freelancing. In short,
all these experiences have helped me develop exceptional communication, teamwork,
and analytical skills. With my ability to multitask, quickly adjust to people, circumstances,
and responsibilities, I’m sure that we could make a good team.


Queue Handling routines for RTOS. More...
#include <stdbool.h>
Data Structures | |
| struct | Osal_Queue_Elem |
| Queue element. More... | |
Typedefs | |
| typedef void * | Osal_Queue_Handle |
Functions | |
| void | Osal_Queue_construct (void *structPtr, const void *queueParams) |
| Function to construct the queue. More... | |
| Osal_Queue_Handle | Osal_Queue_handle (void *structPtr) |
| Function to return the queue handle from the structure. More... | |
| bool | Osal_Queue_empty (Osal_Queue_Handle queueHandle) |
| Function to perform queue empty chcek. More... | |
| void * | Osal_Queue_get (Osal_Queue_Handle queueHandle) |
| Function to return the element at the front of the queue. More... | |
| void | Osal_Queue_put (Osal_Queue_Handle queueHandle, Osal_Queue_Elem *ptr) |
| Function to put the element to the queue. More... | |
Queue Handling routines for RTOS.
============================================================================


railo-context.Component coldbox.system.web.flash.AbstractFlashScope
Copyright Since 2005 ColdBox Framework by Luis Majano and Ortus Solutions, Corp www.coldbox.org | www.luismajano.com | www.ortussolutions.com An abstract flash scope that can be used to build ColdBox Flash scopes. In order to build scopes you must implement the following methods: - clearFlash() A method that will destroy the flash storage - saveFlash() A method that will be called before relocating so the storage can be saved - flashExists() A method that tells ColdBox if the storage exists and if it has content to inflate - getFlash() A method that returns the flash storage All these methds can use any of the concrete methods below. The most important one is the getScope() method which will most likely be called by the saveFlash() method in order to persist the flashed map.
| Property Summary | ||||
|---|---|---|---|---|
| type | property | default | serializable | required |
any
|
controller
ColdBox Controller. |
true
|
false
|
|
any
|
defaults
Flash Defaults. |
true
|
false
|
|
any
|
properties
Flash Properties. |
true
|
false
|
| Constructor Summary | |
|---|---|
|
init(any controller, struct defaults='[runtime expression]')
Constructor. |
| Method Summary | |
|---|---|
any
|
clear()
Clear the temp flash scope and remove all data. |
any
|
clearFlash()
Clear the flash storage. |
any
|
discard([string keys=''])
Keep all or a single flash temp variable alive for another relocation. |
boolean
|
exists(any name)
Check if an object exists in flash scope. |
boolean
|
flashExists()
Checks if the flash storage exists and IT HAS DATA to inflate. |
any
|
get(any name, [any defaultValue])
Get an object from flash scope. |
string
|
getController()
get: ColdBox Controller. |
string
|
getDefaults()
get: Flash Defaults. |
struct
|
getFlash()
Get the flash storage structure to inflate it. |
string
|
getKeys()
Get a list of all the objects in the temp flash scope. |
string
|
getProperties()
get: Flash Properties. |
any
|
getProperty(any property)
Get a named property. |
struct
|
getScope()
Get the flash temp request storage used throughout a request until flashed at the end of a request. |
private any
|
getUtil()
Get utility object. |
any
|
inflateFlash()
|
boolean
|
isEmpty()
Check if the flash scope is empty or not. |
any
|
keep([string keys=''])
Keep all or a single flash temp variable alive for another relocation. |
any
|
persistRC([any include=''], [any exclude=''], [boolean saveNow='false'])
Persist keys from the coldbox request collection in flash scope. |
any
|
propertyExists(any property)
Check a named property. |
any
|
put(string name, any value, [boolean saveNow='false'], [boolean keep='true'], [boolean inflateToRC='[runtime expression]'], [boolean inflateToPRC='[runtime expression]'], [boolean autoPurge='[runtime expression]'])
Keep all or a single flash temp variable alive for another relocation. |
any
|
putAll(struct map, [boolean saveNow='false'], [boolean keep='true'], [boolean inflateToRC='[runtime expression]'], [boolean inflateToPRC='[runtime expression]'], [boolean autoPurge='[runtime expression]'])
Put a map of name-value pairs into the flash scope. |
any
|
remove(any name, [boolean saveNow='false'])
Remove an object from flash scope. |
any
|
removeFlash()
Remove the entire flash storage. |
any
|
saveFlash()
Save the flash storage in preparing to go to the next request. |
any
|
setController(any controller)
set: ColdBox Controller. |
any
|
setDefaults(any defaults)
set: Flash Defaults. |
any
|
setProperties(any properties)
set: Flash Properties. |
any
|
setProperty(any property, any value)
Set a named property. |
numeric
|
size()
Get the size of the items in flash scope. |
private any
|
statusMarks([string keys=''], [boolean keep='true'])
Change the status marks of the temp scope entries. |
| Methods inherited from class railo-context.Component |
|---|
| None |
| Constructor Detail |
|---|
Constructor
controller
- ColdBox Controllerdefaults
- Default flash data packet for the flash RAM object=[scope,properties,inflateToRC,inflateToPRC,autoPurge,autoSave]| Property Detail |
|---|
ColdBox Controller
required
- falseserializable
- trueFlash Defaults
required
- falseserializable
- trueFlash Properties
required
- falseserializable
- true| Method Detail |
|---|
Clear the temp flash scope and remove all data
Clear the flash storage
Keep all or a single flash temp variable alive for another relocation
keys
- The keys in the flash RAM that you want to mark to be kept until the next requestCheck if an object exists in flash scope
name
- The name of the valueChecks if the flash storage exists and IT HAS DATA to inflate.
Get an object from flash scope
name
- The name of the valuedefaultValue
- The default value if the scope does not have the object"get: ColdBox Controller
get: Flash Defaults
Get the flash storage structure to inflate it.
Get a list of all the objects in the temp flash scope
get: Flash Properties
Get a named property
property
- The property nameGet the flash temp request storage used throughout a request until flashed at the end of a request.
Get utility object
Check if the flash scope is empty or not
Keep all or a single flash temp variable alive for another relocation
keys
- The keys in the flash RAM that you want to mark to be kept until the next requestPersist keys from the coldbox request collection in flash scope. If using exclude, then it will try to persist the entire rc but excluding. Including will only include the keys passed
include
- MUTEX: A list of request collection keys you want to persistexclude
- MUTEX: A list of request collection keys you want to exclude from persisting. If sent, then we inspect all rc keys.saveNow
- Whether to send the contents for saving to flash ram or not. Default is to wait for a relocationCheck a named property
property
- The property nameKeep all or a single flash temp variable alive for another relocation
name
- The name of the valuevalue
- The value to storesaveNow
- Whether to send the contents for saving to flash ram or not. Default is to wait for a relocationkeep
- Whether to mark the entry to be kept after saving to the flash storage.inflateToRC
- Whether this flash variable is inflated to the Request Collection or notinflateToPRC
- Whether this flash variable is inflated to the Private Request Collection or notautoPurge
- Flash memory auto purges variables for you. You can control this purging by saying false to autoPurgePut a map of name-value pairs into the flash scope
map
- The map of data to flashsaveNow
- Whether to send the contents for saving to flash ram or not. Default is to wait for a relocationkeep
- Whether to mark the entry to be kept after saving to the flash storage.inflateToRC
- Whether this flash variable is inflated to the Request Collection or notinflateToPRC
- Whether this flash variable is inflated to the Private Request Collection or notautoPurge
- Flash memory auto purges variables for you. You can control this purging by saying false to autoPurgeRemove an object from flash scope
name
- Whether to send the contents for saving to flash ram or not. Default is to wait for a relocationsaveNow
- trueRemove the entire flash storage
Save the flash storage in preparing to go to the next request
set: ColdBox Controller
controller
set: Flash Defaults
defaults
set: Flash Properties
properties
Set a named property
property
- The property namevalue
- The valueGet the size of the items in flash scope
Change the status marks of the temp scope entries
keys
keep


Components
Purpose is built as a framework from the ground-up with design system principles in mind giving you a powerful tool that can help you achieve any kind of result in matters of website building. You get all the Bootstrap’s components, plus tones of new ones specially created for Purpose. On top of that, these can be easily customized with a few variable changes. Purpose is unlike any other themes.


Main Site
Main Nav
Hero Photo Section
Members
Become A Member
What is membership for?
Lorem ipsum dolor sit amet consectetur adipisicing elit. Deleniti inventore magnam, veniam incidunt ducimus sint. Nesciunt minus eaque repellat aliquam cumque voluptate porro neque consectetur vero, eos adipisci sequi illum?
Ready to join the LRG officiating team?
View Game Scheduling
Engagement Section
{{engage.engage_title}}
{{engage.engage_text}}
Additional Resources
Our partner Certification Recertification Clinics and contacts.Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut


Jekyll, like any static site generator produces, well, static sites. This means that a static site is mainly plain old HTML. And HTML cannot send emails. Server-side languages, like PHP, Ruby or Python can send emails.
Since we do not (and do not want to) have the luxury of a server-side language, in order to have a contact form, we need to rely on third party services. Luckily, there are more than one such services which help us receive contact emails, with minimum effort and time spent.
Yellowblue uses such a service, called Formspree and provides you with a ready made contact form. You can see it by clicking on the menu's 'Contact' link in the demo site.
In order for your contact form to work, it needs a little bit of configuration. After all, you have to at least provide your own email address, haven't you?
Open the contact/index.html
file and locate this line:
<form<EMAIL_ADDRESS>method="POST">
and replace<EMAIL_ADDRESS>with your own email address.
A couple more changes;
Notice the page's Front Matter section:
---
layout: page
title: Contact Me
site-url: "http://localhost:4000"
---
You can change the title
variable, that's ,duh, the page's title, or just leave it as it is.
As for the site-url
variable, you assign it to the site's URL. The variable is set to the default Jekyll's URL while working locally and you probably will leave it there while testing the contact form on your local machine. This variable helps Formspree to redirect the user back to your site, after the form has been submitted. So when your site goes live, do not forget to change the site-url
variable!
See this line?
{% assign response = '/thank-you' | prepend: page.site-url %}
In this line we are preparing Formspree to return to a page with a permalink of thank-you
, after a successful form submission.
The code for the thank you page is inside the thank-you/index.html
file. You can leave it or modify it to your own liking.
Before unleashing the form into the wild, test it yourself. The first time you will use it, Formspree will ask you to confirm your email address.
Lastly, do not forget to visit Formspree's website, for further information and documentation.


Titanium Module for Voice Recognition on Android.
In nature, we can write Voice Recognition routine by the following blog entry, but the code in this entry did not work in Android 2.x and Titanium 2.0.1GA environment. This is because "Ti.Android.currentActivity.startActivityForResult" function does not call callback function correctly.
http://www.matthuggins.com/articles/android-voice-recognition-in-appcelerator-titanium
Using this module, we can get Voice Recognition result correctly on Android 2.x, 3.x, 4.0.3, 4.2
Android min-sdk: Android 2.2 (API Level 8)
Titanium 2.1.2GA or later
To access this module from JavaScript, you would do the following:
var voicerecognition = require("org.mumumu.ti.android.speech");
The voicerecognition variable is a reference to the Module object.
O) download repository archive from this site.
A) place dist/org.mumumu.ti.android.speech-android-0.3.zip to your Titanium project root.
B) add the following setting to tiapp.xml between <ti:app> tag.
<modules>
<module version="0.3">org.mumumu.ti.android.speech</module>
</modules>
C) Invoke the module code.
if (Ti.Platform.name == "android") {
var speechModule = require('org.mumumu.ti.android.speech');
var voiceRecognitionProxy = speechModule.createVoiceRecognition();
var callback_func = function (e) {
var voice_recognition_enabled = e.voice_enabled;
var voice_results = e.voice_results;
if (e.voice_canceled) {
alert("voice recognition canceled");
} else {
if (!voice_recognition_enabled) {
alert("voice recognition seems to be disabled");
} else {
alert(voice_results[0]); // array.
}
}
};
voiceRecognitionProxy.voiceRecognition({
"android.speech.extra.PROMPT": "please say something",
"android.speech.extra.LANGUAGE_MODEL": "free_form",
"callback": callback_func
});
}
Yoshinari Takaoka (reversethis -> gro tod umumum ta umumum)
BSD License. See License.txt for details.


Ragù
Ingredients
- 1 pound tubular dried pasta
- 1 pound sweet Italian sausage
- 1 onion, minced
- 1 carrot, minced
- 1 celery stalk, minced
- 28oz (825 ml) can of whole tomatoes
- 3 tablespoon of tomato paste
- ¼ cup fresh parsley
- 1 sprig of fresh thyme
- 1 sprig of fresh rosemary
- grated Parmesan cheese (optional)
- extra-virgin olive oil
Directions
- Sauté sausage crumbles in a large pan or dutch oven over medium-low heat.
Add enough olive oil to gently fry the crumbles.
Cook about five minutes until opaque, not browned.
- Add minced onion, carrot, and celery, and parsley to the pan.
Stir often and add more olive oil if pan is dry.
Cook 30 minutes on very low heat until vegetables are caramelized and sausage is browned.
- Add canned tomatoes and their juice.
Break up tomatoes in the pan.
- Bring to a simmer then add thyme and rosemary
- Continue simmer uncovered for 20 minutes, until thickened.
- Mix tomato paste with 1 cup of hot water.
Reduce heat to very low and add mix to the pan.
- Cook about 10 minutes until the sauce is dark red and glistens with oil.
- Remove herb sprigs and add pepper to taste.
- Meanwhile, boil large pot of salted water then cook and drain the pasta.
- Serve ragù over plate of pasta and top with grated parmesan cheese;
Contribution
Support the site.
Luke’s Vultr referral credits won’t last forever…
Recipe tags:
italian
pasta
cheesefare
fasting