(just another timm tool)
home | discuss | report bug
Ranges implements discretization; i.e. transform quantitative data into qualitative data. Even for algorithms that can directly deal with quantitative data, dscretization can led to faster, more effective learning.
It turns out that a generic recursive bi-clustering procedure can implement all the following discretization processes:
div
: Separate a List into Ranges from ranges import div
#
for rng in div([ 10, 11, 13, 14, 15, 15, 16, 16, 17,
20, 21, 23, 24, 25, 25, 26, 26, 27,
30, 31, 33, 34, 35, 35, 36, 36, 37
]):
print("range,rng["id"],":",
dict(lo= rng["x"].lo,
hi= rng["x"].hi))
# Output
range 1: {'lo': 10, 'hi': 20} # nums 10 to 20
range 2: {'lo': 21, 'hi': 31} # nums 21 to 31
range 3: {'lo': 33, 'hi': 37} # nums 33 to 37
ediv
: Separate pairs of Number,Symbols into Ranges from ranges import div,ediv
#
a,b = "a","b"
for rng in ediv([
(10,a),(11,a),(13,a),(14,a),(15,a),
(20,b),(21,b),(23,b),(24,b),(25,b),
(30,b),(31,b),(33,b),(34,b),(35,b) ]):
print(dict(id= rng["id"],
lo= rng["x"].lo,
hi= rng["x"].hi))
# Output
range 0 : {'lo': 10, 'hi': 20}
range 1 : {'lo': 21, 'hi': 35}
sdiv
: Separate pairs of Number,Numbers into Ranges lst= [( 0.7, 2), ( 0.75, 2 ), ( 0.8, 2 ),
( 0,85 ,2), ( 0.9, 2), ( 0.8 , 2 ),
( 1 , 2 ), ( 1.05 , 2), ( 1,2),
( 0.7, 2), ( 0.75, 2 ), ( 0.8, 2 ),
( 0.85 , 2), ( 0.9, 2), (10 , 14 ),
(10.5, 13.5),(11 ,13), (11.5, 13),
(12 , 12.5),(12.5, 12 ),(13 ,11.5),
(13.5, 10.5),(14 , 10 ),(14.5, 9.5),
(15 , 9), (15.5, 8.5) ]
for rng in sdiv(lst):
print("range",rng["id"],":",
dict(lo= rng["x"].lo,
hi= rng["x"].hi))
# Output
range 0 : {'lo': 0, 'hi': 0.9}
range 1 : {'lo': 0.9, 'hi': 15.5}
ddiv
: Separate lists of Treatment into Ranges for rng in ddv(dict(x1= [0.34, 0.49, 0.51, 0.6],
x2= [0.6, 0.7, 0.8, 0.9],
x3= [0.15, 0.25, 0.4, 0.35],
x4= [0.6, 0.7, 0.8, 0.9],
x5= [0.1, 0.2, 0.3, 0.4])):
print("range", rng["id"],":",
[x[0].label for x in rng["has"]],
dict(lo= rng["x"].lo,
hi= rng["x"].hi))
# Output
range 0 : ['x5', 'x3'] {'lo': 0.1, 'hi': 0.4}
range 1 : ['x1'] {'lo': 0.34, 'hi': 0.6}
range 2 : ['x2', 'x4'] {'lo': 0.6, 'hi': 0.9}
Ranges
assumes that the input data contains a list of doubles (x,y)
pairs. The process assumes x is always numeric, but y may
be numeric or symbols.
To divide a list of numerics, this generates doubles (x,x), after which the same division process executes.
However it runs, this ranges returns a list of dictionaries:
dict(label = label, score = score,
x = xoverall, # x.lo, x.hi defines the range
y = yoverall, # could be numerics or symbols
has = items,
id = aNumber)
import sys,math
from cliffsDelta import cd as different
from bootstrap import bootstrap
Short-cuts, defined for standard usages.
Standard usage #1: divide a list of numbers.
def div(lst):
return ranges(lst)
Standard usage #2:
def sdiv(lst,
x = lambda z:z[ 0],
y = lambda z:z[-1],
key = lambda z:z[ 0]):
return ranges(lst, key=key, x=x, y=y)
def ediv(lst,
x = lambda z:z[ 0],
y = lambda z:z[-1],
key = lambda z:z[ 0]):
def fayyadIranni(lhs,rhs,all,score):
gain = all.ent() - score
delta = math.log(3**all.k()-2,2) - (all.ke() - lhs.ke() - rhs.ke())
return gain > (math.log(all.n-1,2) + delta)/all.n
return ranges(lst,
ynum=False,
goodysplit=fayyadIranni,key=key, x=x, y=y)
def scottknott(d):
def expectedMuChange(lhs,rhs,all):
return lhs.n/all.n * abs(lhs.median() - all.median())**2 + \
rhs.n/all.n * abs(rhs.median() - all.median())**2
return ddiv(d,expectedMuChange)
def ddiv(d,f=None):
lst=[]
for k,v in d.items():
tmp=num(v)
tmp.label= k
lst += [tmp]
return ranges(lst,
flat=False,
x = lambda z:z.all,
y = lambda z:z.all,
key = lambda z:z.median())
def ranges(lst,
d = 0.3,
cliffsDelta= 0.147,
enough = None,
enoughth = 0.71,
epsilon = None,
evaly = None,
flat = True,
goodxsplit = None,
goodysplit = None,
greedy = True,
label = "ranges",
rnd = 3,
trivial = 1.05, # 1%
key = lambda z:z,
verbose = False,
x = lambda z:z,
y = lambda z:z,
ynum = True,
):
def expectedWriggle(lhs,rhs,all):
return lhs.n/all.n * lhs.wriggle() + \
rhs.n/all.n * rhs.wriggle()
def yes(*l,**d): return True
evaly= evaly or expectedWriggle
goodxsplit = goodxsplit or yes
goodysplit = goodysplit or yes
def stats(segment, xall, yall,flat):
xs,ys = num(),yklass()
if flat:
for one in segment:
x1 = x(one)
y1 = y(one)
xs + x1
xall + x1
ys + y1
yall + y1
else:
for x1 in segment.all:
xs.label = segment.label
ys.label = segment.label
xs + x1
xall + x1
ys + x1
yall + x1
return xs,ys
def summary(segments):
xall,yall=[],[]
xs, ys = {},{}
for i,(x,y) in enumerate(segments[::-1]):
j = len(segments) - i - 1
xall += x.all
yall += y.all
newx = num(xall)
newy = yklass(yall)
xs[j] = newx
ys[j] = newy
print("!!!",j,newx,newy)
return xs, ys, num(xall), yklass(yall)
def divide(segments, out,lvl, cut=None):
xrhsall, yrhsall, xoverall, yoverall = summary(segments)
score, score1 = yoverall.wriggle(), None
xlhs, ylhs = num(), yklass()
for i,(x,y) in enumerate(segments[:-1]):
xrhs = xrhsall[i+1]
yrhs = yrhsall[i+1]
[xlhs+z for z in x.all]
[ylhs+z for z in y.all]
if xlhs.median() + epsilon < xrhs.median():
score1 = evaly(ylhs,yrhs,yoverall)
if score1*trivial < score:
if yklass == num:
if not greedy or ylhs.median()*trivial < yrhs.median():
if goodxsplit(xlhs,xrhs,xoverall): # hook for stats
cut,score = i+1,score1
else:
if not greedy or ylhs.mode != yrhs.mode:
if goodysplit(ylhs,yrhs,yoverall, score1):
if goodxsplit(xlhs,xrhs,xoverall): # hook for stats
cut,score = i+1,score1
if verbose:
score1 = round(score1,rnd) if score1 else '.'
print(' ..'*lvl,xoverall.n,score1)
if cut:
divide(segments[:cut], out= out, lvl= lvl+1)
divide(segments[cut:], out= out, lvl= lvl+1)
else:
assert xoverall.lo <= xoverall.hi
out.append(dict(label = label, score = score,
x = xoverall,
y = yoverall,
has = segments,id=len(out)))
return out
def chunks(l, n):
for i in range(0, len(l), n): yield l[i:i + n]
if not lst:
return []
else:
lst = lst[:]
yklass = num if ynum else sym
xall, yall = num(), yklass()
width = int(enough or len(lst)**enoughth)
ordered = sorted(lst,key=key)
segments = ordered if not flat else [z for z in chunks(ordered,width)]
parts = [stats(segment, xall, yall,flat) for segment in segments]
epsilon = epsilon or d * xall.wriggle()
return divide(parts,out=[], lvl=0)
class ordered:
def __init__(i,lst):
i.sorted= False
i._median = None
i.all = lst
def __add__(i,x):
i.sorted=False
i.all += [x]
def wriggle(i):
return i.median()
def median(i):
if not i.sorted or not i._median:
i.sorted = True
i.all = sorted(i.all)
n = len(i.all)
p = q = n//2
if n < 3:
p,q = 0, n-1
elif not n % 2:
q = p -1
i._median = i.all[p] if p==q else (i.all[p]+i.all[q])/2
return i._median
class num:
def __init__(i,inits=[]):
i.lo, i.hi, i.n, i.mu, i.m2 = 1e32,-1e32,0,0,0
i.sd = None
i.all = []
i.ordered=ordered(i.all)
[i + x for x in inits]
def __add__(i,x):
i.ordered + x
i.sorted=False
i.lo = min(x, i.lo)
i.hi = max(x, i.hi)
i.n += 1
delta = x - i.mu
i.mu += delta/i.n
i.m2 += delta*(x - i.mu)
if i.n > 1:
i.sd = (i.m2/(i.n-1))**0.5
def wriggle(i):
return i.sd
def median(i):
return i.ordered.median()
def __repr__(i):
return "(:lo %.4f :hi %.4f :n %.4f :med %.4f :sd %.4f)" % (i.lo, i.hi, i.n,i.median(),i.sd)
class sym:
def __init__(i,inits=[]):
i.n, i.most, i.mode, i.counts = 0,0,None,{}
i.all=[]
i._ent=None
[i + x for x in inits]
def __add__(i,x):
i.all += [x]
i.n += 1
i._ent=None
count= i.counts[x] = i.counts.get(x,0) + 1
if count > i.most:
i.most,i.mode=count,x
def wriggle(i): return i.ent()
def ent(i):
if i._ent is None:
i._ent = 0
for k in i.counts:
p = i.counts[k]/i.n
i._ent -= p*math.log(p,2)
return i._ent
def k(i): return len(i.counts.keys())
def ke(i): return i.k()*i.ent()
Copyright © 2016 Tim Menzies<EMAIL_ADDRESS>This program is free software. It comes without any warranty, to the extent permitted by applicable law. You can redistribute it and/or modify it under the terms of the Do What The F*ck You Want To Public License, Version 2, as published by Sam Hocevar. See http://www.wtfpl.net for more details.
Share and enjoy.


Monday
Tuesday
Wednesday
Thursday
Friday
About Us
Canon
Sign Up
Sign Up
please login :)
Username
Password
Login


iOS libraries
curated by quality
curated by quality
Keep Informed
Subscribe for free resources and news updates.
It's been almost an year since we talked about creating an AwesomeiOS Newsletter.
Our plan is to have a weekly newsletter that showcases quality iOS libraries, frameworks and other iOS developer tools. We decided to create this because we're a big newsletter fan because they always provide amazing new links.


Once you've installed Qt Creator, you can download any of the assignment projects available on the assignment page. Note that to open the project, you have 2 options:
Open Qt Creator.
Go to File->Open File or Project...
Then navigate to the project you wish to open and click on the .pro file, i.e. Life.pro.
Note, if you directly open the *.h files or *.cpp files instead, this will not work, because it will not open the entire project.
Navigate to the project you wish to open in your file system, then just double-click on the .pro file i.e. Life.pro. This will open Qt Creator for you with this project.
Below is a screenshot of what Qt Creator should look like when you open a project.
Let's breakdown what buttons are where and how you actually edit and run the code. First in the picture below is the View menu. This menu allows you to change how qt creator will look, which can help you in different tasks. You'll mainly use the Edit view and the Debug view. Projects will open in Edit view.
The files inside of this project will be displayed in the project files window which can be seen below. Note, if you can't see this window, hold down the Alt key and press 0 (zero, the number key) on Windows or the Meta key and press 0 on Mac. The code files for the project can be found in the Headers → src folder and the Sources → src folder. The files in the lib/StanfordCPPLib folders are the code files for the Stanford Library which includes classes like Vector, Grid, and Map. Feel free to open up these files and take a look. Just make sure not to change them since your assignments will be graded with a clean copy of those files.
But how do you run your programs? First, you'll need to build the project by clicking the Build button which is marked by the hammer icon in the picture below. If the project builds, then you can run the project by clicking the play button which is the plain green triangle button shown in the picture below. If you want to debug your project, you should click the debug button which is the green triangle with a bug on it shown in the picture below. Note, your project must be built in debug mode in order to debug your program. You can change the build mode by clicking the computer icon shown in the picture below and selecting the debug option. Most projects by default are built in debug mode.
The last thing to mention is where to view compiler errors, issues, and application output. At the bottom of your screen, you'll see the Issues, Application Output, and Compiler Output options. You can open these windows to see the corresponding information. Sometimes the explanations in the Issues window is not that helpful. In these cases, you should look at the Compile Output or Application Output to see if that gives you more helpful information.
If you have having trouble finding bugs in your program or just want to learn how to debug with Qt Creator's Debugging Tools, here's a handout for you.


| stobfun {hte} | R Documentation |
Convenience functions for constructing and working with stateful objective functions (‘stobfun’-class objects).
stobfun(
embed,
params,
est = character(0),
log = character(0),
logit = character(0),
objfun,
data,
...
)
filterfun(embed, params, filtfun, data, ...)
transf_fns(log = character(0), logit = character(0), est = character(0))
embedding(...)
## S3 method for class 'stobfun'
coef(object, ...)
embed |
embedding (see |
params |
vector of parameters |
est |
character: names of parameters to be estimated |
log |
character; names of parameters to log transform. |
logit |
character; names of parameters to logit transform. |
objfun |
underlying objective function |
data |
data |
... |
When furnished to |
filtfun |
the function that actually applies the filter |
object |
‘stobfun’-class stateful objective function |
objfun
will be called as objfun(theta,data)
, where
theta
is the nested list constructed according to the given specifications
and data
is the data.
transf_fns
returns a list of two functions.
The first is the transformation to the estimation scale;
the second is its inverse.
embedding
returns the embedding function corresponding to the given specification.
coef(f)
returns the parameter vector corresponding to the last call of the stateful objective function f
.
A stateful objective function is an ordinary function that can be used as an objective function in an optimization problem.
In particular, it can be passed to optimizers such as optim
, subplex
, or nloptr
.
It is stateful in the sense that it remembers the argument with which it was last called.
To construct a stateful objective function, call the constructor function for the model of interest. The constructor function requires that you pass a vector of model parameters: this gives the default parameter values. It also requires that you pass the data and the names of the parameters that you wish to estimate. The constructor will return an object of class ‘stobfun’.
Having constructed a ‘stobfun’ stateful objective function, you can pass this to any suitable optimizer.
Once the optimizer has returned, it is important that you call the function one last time, at the parameters the optimizer has returned (see examples).
This ensures that the stored parameters are those at the (putative) optimum.
You can retrieve these parameters via a call to coef
.
More on stateful objective functions:
independent
,
transmission


The Microsoft SQL Server JDBC Driver provides support for Java Platform, Enterprise Edition (Java EE) connection pooling. The JDBC driver implements the JDBC 3.0 required interfaces to enable the driver to participate in any connection-pooling implementation that is provided by middleware vendors and is JDBC 3.0-compliant. Middleware such as Java EE application servers frequently provides compliant connection-pooling facilities. The JDBC driver will participate in pooled connections in these environments.
The classes for the connection pooling implementation are as follows.
| Class | Implements | Description |
|---|---|---|
|
com.microsoft.sqlserver.jdbc.SQLServerXADataSource |
javax.sql.ConnectionPoolDataSource and javax.sql.XADataSource |
We recommend that you use the SQLServerXADataSource class for all your Java EE server needs, because it implements all the JDBC 3.0 pooling and XA interfaces. |
|
com.microsoft.sqlserver.jdbc.SQLServerConnectionPoolDataSource |
javax.sql.ConnectionPoolDataSource |
This class is a connection factory that enables the Java EE application server to populate its connection pool with physical connections. If the configuration of your Java EE vendor requires a class that implements javax.sql.ConnectionPoolDataSource, specify the class name as SQLServerConnectionPoolDataSource. We generally recommend that you use the SQLServerXADataSource class instead, because it implements both pooling and XA interfaces, and has been verified in more Java EE server configurations. |
JDBC application code should always close connections explicitly to derive the most benefit from pooling. When the application explicitly closes a connection, the pooling implementation can reuse the connection immediately. If the connection is not closed, other applications cannot reuse it. Applications can use the finally
construct to make sure that pooled connections are closed even if an exception occurs.


Welcome to a suite of tools built for the Centre for French & Linguistics to assist students in various linguistics courses.
Currently available tools and experimental projects:


Race Start NPC
Thanks for signup. Stay near me, when we start Race i will transform only players near me!
Without proper transformation you cannot finish Race!


{% include shutdown.html %}
{% t embed_zoomed_out %}
{% include filters.html %}
{% include shutdown.html %}
{% include embed_credits.html %}
---
layout: empty
title: home_title
add_to_nav: false
---


In parallel with the unblu activity, the regular processes of the organization’s web site take place: Requests are forwarded to the organization backend then responses delivered to the visitor’s browser. This (regular) flow is represented in the chart(s) with the black arrows.
The flow of unblu-specific requests is represented in the diagram by red arrows. The unblu Collaboration Server creates a URL ‘map’ which allows it to find the requested images and style sheets. As images and style sheets are not transferred with the Document Object Model (although the ‘space’ on the page where they should be placed is recorded) the unblu Collaboration Server uses this ‘URL map’ to find requested objects. As some objects may be held in the visitor browser cache the unblu server calculates what objects must be fetched to recreate the cached objects on the Agent browser.


a way to grant creators of an original work
exclusive rights over use of that work
for a limited time
dh is a collaborative discipline that...
...both uses and generates copyrightable content.
It's content that is uncopyrightable...
...whether due to age of material or explicit dedication...
...and can be monetized, distributed, messed with, manipulated without limit
Life + 50 (Canada)
1923 (usually) (US)
The right to make copies of portions of copyrighted work...
...without asking permission from the copyright holder...
...for purposes of commentary or study.
We can now...
...record TV shows!
...make backup copies!
...move media to devices!
...when DRM is not present!
it's a copyright, with options...
...allowing redistribution and copying...
...with various levels of restrictions...
...Wikipedia, Arduino, PLOS...
Any questions?


{% extends "reports/base.html" %} {% block content %}
| Received | User | Message {% for report in report_page.object_list %} |
|---|---|---|
| {{ report.upload_date|date:"Y-m-d" }} {{ report.upload_date|date:"H:i:s" }} | {{ report.user_id_hash|slice:"0:8" }} | {{ report.data }} {% endfor %} |


An Academic Management Software is at your own hands! Join and Connect with Us.
*Required
We can provide the Best intel to the Students about Carrier Development, Opportunities and Best interface for All other College Faculties and helps Students(via Authorities) to Connect with Companies.
Conduct discussion forums on various topics to boost the academics, conduct group discussions, and to improve the collaboration over team projects.
Provide All the Details of College Events/Programs occuring in a Particular months and to improve research on the topic.
Helps the placement officer to manage all placement activities in one place.
Helps Students,Faculties to connect with the Companies through chatting, Video Conference like other Communication mediums.
Collect real-time performance data for continuous improvements and enhancements and develop it to the best fit.
All the members can consult on various questions or other Study related topics through Notification Tab.
If you are facing Bugs or Errors then please inform us and to develop more features and suggestion, share with us.
MES COLLEGE OF ENGINEERING
Kuttipuram,Thrikkanapuram P.O
Kerala-INDIA
<EMAIL_ADDRESS><EMAIL_ADDRESS>Phone:<PHONE_NUMBER>
Mobile:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>


This card contains the styling of the global button types
button html tag with ion-button attr on
primary button html tag with ion-button attr on
secondary button html tag with ion-button attr on


Direct-Response Digital Marketer
Full-Stack Software Engineer
Exercise Physiologist
Team Player
Fast Learner
Problem Solver
100% Made in Italy 🇮🇹, born and raised in Monza. I Moved to Miami in 2010 to attend University and graduated Cum Laude in 2014 with a degree in Exercise Physiology and Chemistry.
After dedicating two years to medical research I fell in love with the art of programming and software engineering.


Save your progress - soft intro to git
This is an introduction on saving your code the way a developer does – through source control management. git is what is used for these tutorials.
What is git?
git is software. You use git to help manage your source code. While you still “Save” your code files the traditional way through your text editor, it is good practice (and used by professional engineers and hobbyists alike) to “save” your code with a source code management tool.
Instead of “Save” and “Save As”, you “commit” your code to your local repository. A repository (a.k.a. repo) can be thought of the main, root directory for a project or a package.
A bit of context, git was initially designed and developed Linus Torvalds for the development of Linux.
Git and GitHub
Do not confuse git and GitHub!* git is software, GitHub is a company that offers remote hosting for your git repositories (rather than just having a local copy on your machine). BitBucket is also a company that offers remote hosting for your git repositories (as well as Mercurial repositories). Simply put, they offer a social aspect to coding – allowing you to connect to other developers.
To setup git locally on your machine, GitHub has a few great resources:
Resources for using git:
Your workflow with git
With git, users can do what’s called branching and merging. With a repo, you have a main, original branch called master. Off of master, you can make branches. Consider this to give you the ability to play around with code, break things, etc, while keeping the original/master safe. If you’re happy with what has been completed within a branch, you merge the branch into the master branch, and it becomes your new original.
It’s good to start off using git with good habits. Whenever you start something new, like as soon as you clone a repository, one good habit is to make a branch to merge in later when you’re satisfied with your progress.
When you are intermittingly saving your progress on a branch, make a commit to your branch. Commit your code regularly, whether when you’re done for the day, when you‘ve finished coding out one of the parts of the tutorial, before you answer the phone when someone calls you, etc. Rather than making one big “atomic” commit at big milestones (e.g. after the completion of one tutorial, an implementation of a feature), doing this makes it very easy to undo changes that you’ve made without losing big progress.
One awesome feature about git is that once you are ready to merge the branch into master, you can do what’s called squashing your commits into one big one. So, sure, you’ve made many commits - perhaps they’re many commits with one line of code or typos.
Here is a sample workflow of making a respository, branching, committing, squashing, then merging into master.
Within your terminal, we will initialize our repository and get the newcoder code base:
## make a Projects folder and move into that folder (change directories) $ mkdir Projects && cd Projects ## initialize/create a new git repository $ git init ## add a reference (a link) to my repository, naming it "upstream" $ git remote add upstream https://github.com/econchick/new-coder.git ## pull in my repo (the master branch) from the above GitHub link into your repository $ git pull upstream master ## check the status of your repository $ git status # On branch master nothing to commit (working directory clean)
Now, let’s create a branch for our development:
## create a branch to start doing your work for the first tutorial, dataviz $ git branch dataviz ## switch to the dataviz branch $ git checkout dataviz ## go ahead and start coding and working.
 We first have to add the file(s) that you’ve changed so that git knows to track them, then commit with a message for your reference:
## when you need to stop, or when you’ve made some changes you want ## to keep, you first add the files for git to track & commit: $ git status # On branch master # Your branch is ahead of 'origin/master' by 4 commits. # # Changes not staged for commit: # (use "git add..." to update what will be committed) # (use "git checkout -- ..."  # # If you remove a line here THAT COMMIT WILL BE LOST. # However, if you remove everything, the rebase will be aborted.
This is a vi screen (a text editory within the terminal). To use vi, there are special keys to edit and move around. Press i
to start editing, and move up and down with your keyboard’s arrow keys.
Notice the pick
by each of the three commits that you’ve recently done. We will edit the latest two commits to say squash
. When done, press the following keys to save: ESC
+ :
+ w
+ q
+ Enter
:
pick 77578d6 fixing typo in my code squash f7629fe figured out the graph functions squash aa2a2e3 part 1 of dataviz tutorial # Rebase c59a19b..aa2a2e3 onto c59a19b # # Commands: # p, pick = use commit # r, reword = use commit, but edit the commit message # e, edit = use commit, but stop for amending # s, squash = use commit, but meld into previous commit # f, fixup = like "squash", but discard this commit's log message # x, exec = run command (the rest of the line) using shell # # These lines can be re-ordered; they are executed from top to bottom. # # If you remove a line here THAT COMMIT WILL BE LOST. # However, if you remove everything, the rebase will be aborted.
Now you will see a new vi screen to edit:
# This is a combination of 3 commits. # The first commit's message is: typo in my code # This is the 2nd commit message: figured out the graph functions # This is the 3rd commit message: part 1 of dataviz tutorial # Please enter the commit message for your changes. Lines starting # with '#' will be ignored, and an empty message aborts the commit. # Not currently on any branch. # Changes to be committed: # (use "git reset HEAD..." to unstage) # # modified: dataviz/tutorial_source/parse.py #
You can now edit these messages to have one single message. This is essentially rewriting history, so let’s write a meaningful commit message. The lines starting with #
will be ignored. When done editing, press ESC
+ :
+ w
+ q
+ Enter
.
# This is a combination of 3 commits. # The first commit's message is: Completed the dataviz tutorial # Please enter the commit message for your changes. Lines starting # with '#' will be ignored, and an empty message aborts the commit. # Not currently on any branch. # Changes to be committed: # (use "git reset HEAD..." to unstage) # # modified: dataviz/tutorial_source/parse.py #
Now you should see a message to the following;
Created commit 0fc4eea: Completed the dataviz tutorial 1 files changed, 14 insertions(+), 13 deletions(-) Successfully rebased and updated refs/heads/dataviz.
Ok now that we’ve squashed & rebased our many commits into one, we should merge our progress onto master:
$ git checkout master $ git merge dataviz
You should now see the one squashed commit in the commit log:
$ git log commit 90b4bdb388480529b1524b6afedbb0fab0fc4eea Author: Lynn RootDate: Thu Mar 14 10:48:25 2013 -0700 Completed the dataviz tutorial
However, you have not lost the commits you’ve squashed. To see all commits:
$ git reflog 0fc4eea HEAD@{0}: rebase -i (finish): returning to refs/heads/master 0fc4eea HEAD@{1}: rebase -i (squash): Completed the dataviz tutorial aa2a2e3 HEAD@{2}: commit: part 1 of dataviz tutorial f7629fe HEAD@{3}: commit: figured out the graph functions 77578d6 HEAD@{4}: commit: typo in my code
That’s it! You can find another quick tutorial on squashing git commits here.
Benefit to using GitHub or BitBucket
When you have code up on GitHub and/or BitBucket, not only do they implicitly provide back up to your code in case anything happens to your local machine, but it also is a resume for you as a developer.
As you work through these tutorials, I encourage you to use GitHub or BitBucket (or any other service that allows you to publicly share repositories) to “push” your code to so others can see your progress. While I suggest you to locally commit often and commit happily, only push code to GitHub/BitBucket when there is a good completion point (e.g. when you've finished a tutorial).


NRPN 26,0 on the Editor input moves a program file into another location. The Bank MSB and Data MSB specify the destination, and the Bank LSB and Data LSB specify the source. This is echoed back to the editor.
If the source and destination both exist, the source overwrites the destination; if the source doesn't exist, the destination is deleted. The source ends up empty.


User Experience is only successful if everyone is involved and on-board. User Experience Designers aren’t the only one who has an impact on the end user — any decision made by someone at a business can be filtered through the lens of UX. As UX professionals, we have a duty to educate those around us.
I’ve been involved in building the UX community in Milwaukee since 2016; as a speaker since 2015.
Interested in having me give a lunch and learn, after-work presentation or something else? Email me!


{% load socialaccount %} {% get_providers as socialaccount_providers %} {% for provider in socialaccount_providers %} {% if provider.id == "openid" %} {% for brand in provider.get_brands %} Sign in with {{brand.name}} {% endfor %} {% endif %}
We highly recommend that you log in with GitHub although you can always connect your GitHub account later.
Sign in with {{provider.name}} {% endfor %}


Announcing Apache Flink 0.10.0
November 16, 2015 -The Apache Flink community is pleased to announce the availability of the 0.10.0 release. The community put significant effort into improving and extending Apache Flink since the last release, focusing on data stream processing and operational features. About 80 contributors provided bug fixes, improvements, and new features such that in total more than 400 JIRA issues could be resolved.
For Flink 0.10.0, the focus of the community was to graduate the DataStream API from beta and to evolve Apache Flink into a production-ready stream data processor with a competitive feature set. These efforts resulted in support for event-time and out-of-order streams, exactly-once guarantees in the case of failures, a very flexible windowing mechanism, sophisticated operator state management, and a highly-available cluster operation mode. Flink 0.10.0 also brings a new monitoring dashboard with real-time system and job monitoring capabilities. Both batch and streaming modes of Flink benefit from the new high availability and improved monitoring features. Needless to say that Flink 0.10.0 includes many more features, improvements, and bug fixes.
We encourage everyone to download the release and check out the documentation. Feedback through the Flink mailing lists is, as always, very welcome!
New Features #
Event-time Stream Processing #
Many stream processing applications consume data from sources that produce events with associated timestamps such as sensor or user-interaction events. Very often, events have to be collected from several sources such that it is usually not guaranteed that events arrive in the exact order of their timestamps at the stream processor. Consequently, stream processors must take out-of-order elements into account in order to produce results which are correct and consistent with respect to the timestamps of the events. With release 0.10.0, Apache Flink supports event-time processing as well as ingestion-time and processing-time processing. See FLINK-2674 for details.
Stateful Stream Processing #
Operators that maintain and update state are a common pattern in many stream processing applications. Since streaming applications tend to run for a very long time, operator state can become very valuable and impossible to recompute. In order to enable fault-tolerance, operator state must be backed up to persistent storage in regular intervals. Flink 0.10.0 offers flexible interfaces to define, update, and query operator state and hooks to connect various state backends.
Highly-available Cluster Operations #
Stream processing applications may be live for months. Therefore, a production-ready stream processor must be highly-available and continue to process data even in the face of failures. With release 0.10.0, Flink supports high availability modes for standalone cluster and YARN setups, eliminating any single point of failure. In this mode, Flink relies on Apache Zookeeper for leader election and persisting small sized meta-data of running jobs. You can check out the documentation to see how to enable high availability. See FLINK-2287 for details.
Graduated DataStream API #
The DataStream API was revised based on user feedback and with foresight for upcoming features and graduated from beta status to fully supported. The most obvious changes are related to the methods for stream partitioning and window operations. The new windowing system is based on the concepts of window assigners, triggers, and evictors, inspired by the Dataflow Model. The new API is fully described in the DataStream API documentation. This migration guide will help to port your Flink 0.9 DataStream programs to the revised API of Flink 0.10.0. See FLINK-2674 and FLINK-2877 for details.
New Connectors for Data Streams #
Apache Flink 0.10.0 features DataStream sources and sinks for many common data producers and stores. This includes an exactly-once rolling file sink which supports any file system, including HDFS, local FS, and S3. We also updated the Apache Kafka producer to use the new producer API, and added a connectors for ElasticSearch and Apache Nifi. More connectors for DataStream programs will be added by the community in the future. See the following JIRA issues for details FLINK-2583, FLINK-2386, FLINK-2372, FLINK-2740, and FLINK-2558.
New Web Dashboard & Real-time Monitoring #
The 0.10.0 release features a newly designed and significantly improved monitoring dashboard for Apache Flink. The new dashboard visualizes the progress of running jobs and shows real-time statistics of processed data volumes and record counts. Moreover, it gives access to resource usage and JVM statistics of TaskManagers including JVM heap usage and garbage collection details. The following screenshot shows the job view of the new dashboard.
The web server that provides all monitoring statistics has been designed with a REST interface allowing other systems to also access the internal system metrics. See FLINK-2357 for details.
Off-heap Managed Memory #
Flink’s internal operators (such as its sort algorithm and hash tables) write data to and read data from managed memory to achieve memory-safe operations and reduce garbage collection overhead. Until version 0.10.0, managed memory was allocated only from JVM heap memory. With this release, managed memory can also be allocated from off-heap memory.  See the documentation to learn how to configure managed memory on off-heap memory. JIRA issue FLINK-1320 contains further details.
Outer Joins #
Outer joins have been one of the most frequently requested features for Flink’s DataSet API. Although there was a workaround to implement outer joins as CoGroup function, it had significant drawbacks including added code complexity and not being fully memory-safe. With release 0.10.0, Flink adds native support for left, right, and full outer joins to the DataSet API. All outer joins are backed by a memory-safe operator implementation that leverages Flink’s managed memory. See FLINK-687 and FLINK-2107 for details.
Gelly: Major Improvements and Scala API #
Gelly is Flink’s API and library for processing and analyzing large-scale graphs. Gelly was introduced with release 0.9.0 and has been very well received by users and contributors. Based on user feedback, Gelly has been improved since then. In addition, Flink 0.10.0 introduces a Scala API for Gelly. See FLINK-2857 and FLINK-1962 for details.
More Improvements and Fixes #
The Flink community resolved more than 400 issues. The following list is a selection of new features and fixed bugs.
- FLINK-1851 Java Table API does not support Casting
- FLINK-2152 Provide zipWithIndex utility in flink-contrib
- FLINK-2158 NullPointerException in DateSerializer.
- FLINK-2240 Use BloomFilter to minimize probe side records which are spilled to disk in Hybrid-Hash-Join
- FLINK-2533 Gap based random sample optimization
- FLINK-2555 Hadoop Input/Output Formats are unable to access secured HDFS clusters
- FLINK-2565 Support primitive arrays as keys
- FLINK-2582 Document how to build Flink with other Scala versions
- FLINK-2584 ASM dependency is not shaded away
- FLINK-2689 Reusing null object for joins with SolutionSet
- FLINK-2703 Remove log4j classes from fat jar / document how to use Flink with logback
- FLINK-2763 Bug in Hybrid Hash Join: Request to spill a partition with less than two buffers.
- FLINK-2767 Add support Scala 2.11 to Scala shell
- FLINK-2774 Import Java API classes automatically in Flink’s Scala shell
- FLINK-2782 Remove deprecated features for 0.10
- FLINK-2800 kryo serialization problem
- FLINK-2834 Global round-robin for temporary directories
- FLINK-2842 S3FileSystem is broken
- FLINK-2874 Certain Avro generated getters/setters not recognized
- FLINK-2895 Duplicate immutable object creation
- FLINK-2964 MutableHashTable fails when spilling partitions without overflow segments
Notice #
As previously announced, Flink 0.10.0 no longer supports Java 6. If you are still using Java 6, please consider upgrading to Java 8 (Java 7 ended its free support in April 2015).
Also note that some methods in the DataStream API had to be renamed as part of the API rework. For example the groupBy
method has been renamed to keyBy
and the windowing API changed. This migration guide will help to port your Flink 0.9 DataStream programs to the revised API of Flink 0.10.0.
Contributors #
- Alexander Alexandrov
- Marton Balassi
- Enrique Bautista
- Faye Beligianni
- Bryan Bende
- Ajay Bhat
- Chris Brinkman
- Dmitry Buzdin
- Kun Cao
- Paris Carbone
- Ufuk Celebi
- Shivani Chandna
- Liang Chen
- Felix Cheung
- Hubert Czerpak
- Vimal Das
- Behrouz Derakhshan
- Suminda Dharmasena
- Stephan Ewen
- Fengbin Fang
- Gyula Fora
- Lun Gao
- Gabor Gevay
- Piotr Godek
- Sachin Goel
- Anton Haglund
- Gábor Hermann
- Greg Hogan
- Fabian Hueske
- Martin Junghanns
- Vasia Kalavri
- Ulf Karlsson
- Frederick F. Kautz
- Samia Khalid
- Johannes Kirschnick
- Kostas Kloudas
- Alexander Kolb
- Johann Kovacs
- Aljoscha Krettek
- Sebastian Kruse
- Andreas Kunft
- Chengxiang Li
- Chen Liang
- Andra Lungu
- Suneel Marthi
- Tamara Mendt
- Robert Metzger
- Maximilian Michels
- Chiwan Park
- Sahitya Pavurala
- Pietro Pinoli
- Ricky Pogalz
- Niraj Rai
- Lokesh Rajaram
- Johannes Reifferscheid
- Till Rohrmann
- Henry Saputra
- Matthias Sax
- Shiti Saxena
- Chesnay Schepler
- Peter Schrott
- Saumitra Shahapure
- Nikolaas Steenbergen
- Thomas Sun
- Peter Szabo
- Viktor Taranenko
- Kostas Tzoumas
- Pieter-Jan Van Aeken
- Theodore Vasiloudis
- Timo Walther
- Chengxuan Wang
- Huang Wei
- Dawid Wysakowicz
- Rerngvit Yanggratoke
- Nezih Yigitbasi
- Ted Yu
- Rucong Zhang
- Vyacheslav Zholudev
- Zoltán Zvara