Thrift is a framework for creating interoperable and scalable services. Thrift was originally developed at Facebook, and contributed to Apache in order to foster greater use. Thrift is released under the Apache 2.0 license.
Through a simple and straight-forward Interface Definition Language (IDL), Thrift allows you to define and create services that are both consumable by and serviceable by numerous languages. Using code generation, Thrift creates a set of files that can then be used to create clients and/or servers. In addition to interoperability, Thrift can be very efficient through a unique serialization mechanism that is efficient in both time and space.
The choice of programming language at Facebook is based on what language is best suited for the task at hand. While pragmatic, this flexibility resulted in some difficulties when these applications needed to call one another. After analysis, Facebook's engineers did not find anything currently existing that met their needs of interoperability, transport efficiency, and simplicity (amongst others). Out of this need, Facebook's engineers developed efficient protocols and a services infrastructure that became Thrift. Facebook now uses Thrift for their back-end services - the reason for which it was designed.
This article is structured in the following topics:
Thrift includes a complete stack for creating clients and servers. The diagram below depicts the Thrift stack.
The top portion of the stack is generated code from your Thrift definition file. Thrift services result in generated client and processor code. These are represented by the brown boxes in the diagram. The data structures that are sent (other than built-in types) also result in generated code. These result in the red boxes. The protocol and transport are part of the Thrift runtime library. Therefore with Thrift, you can define a service, and are free to change the protocol and transport without re-generating your code.
Thrift also includes a server infrastructure to tie the protocols and transports together. There are blocking, non-blocking, single and multithreaded servers available.
The "Underlying I/O" portion of the stack differs based on the language in question. For Java and Python network I/O, the built-in libraries are leveraged by the Thrift library, while the C++ implementation uses its own custom implementation.
Thrift allows you to choose independently between your protocol, transport and server. With Thrift being originally developed in C++, Thrift has the greatest variation among these in the C++ implementation.
Thrift supports both text and binary protocols. The binary protocols outperform the text protocols, but there are times when the text protocols may be useful (such as in debugging). Some of the protocols Thrift supports:
While the above protocols describe "what" is transmitted, Thrift's transports are the "how". Here are a number of transports that Thrift supports:
Lastly, Thrift provides a number of servers:
Thrift allows only one service per server. Although this is certainly a limitation, this can be accommodated through a work-around. By defining a composite service that extends all of the other services that a given server should process, a single server can thus accommodate multiple services. If this work-around is insufficient for your needs, you can always create multiple servers. This scenario would mean however you would be using more resources than necessary (ports, memory, etc.).
Given that the TCompactProtocol is the most-efficient method in the Java implement of Thrift and the example used throughout this article, some further explanation of the protocol is warranted. This protocol writes numeric tags for each piece of data. The recipient is expected to properly match these tags with the data. If the data is not present, there simply is no tag/data pair.
For integers, the TCompactProtocol performs compression using Variable-Length Quantity (VLQ) encoding from the MIDI file format. VLQ is a relatively simple format that uses 7 of 8 bits out of each byte for information, with the 8th bit used as a continuation bit. VLQ's worst-case encoding is acceptable. For a 32bit int, it is 5 bytes. For 64 bit ints, it is 10 bytes. The diagram below shows how the decimal value 106903 (0x1A197) is represented in VLQ, saving 1 byte if it was stored in 32 bits:
Creating a Thrift service first requires creating a Thrift file describing a service, generating the code for the service, and finally writing some supporting code to start the service and client code to call it.
A Thrift definition file should be familiar to anyone who knows any language with a c syntax. Thrift files use keywords such as struct and int as well as curly braces for containing types and parenthesis for parameter lists. Thrift allows you to transfer both simple and complex types. Let's create a service for managing courses and students.
senum PhoneType { "HOME", "WORK", "MOBILE" "OTHER" } struct Phone { 1: i32 id, 2: string number, 3: PhoneType type }
Here we have a Phone which contains an id, number and type. The phone number is a simple string, while the type is an enumeration limited to the values "HOME", "WORK", "MOBILE" and "OTHER". Thrift uses the struct keyword to define a simple structure and senum for an enumeration. The Java generated code will create a POJO class for struct as you might expect. Disappointingly senum will not result in an Enum, but rather a simple Java String in the Phone class.
Note the numeric identifiers preceding each element in the struct. These identifiers are used during serialization/deserialization to speed parsing and minimize the size of the metadata. These numeric identifiers are what are passed over the wire rather than the string names of elements.
struct Person { 1: i32 id, 2: string firstName, 3: string lastName, 4: string email, 5: list<Phone> phones } struct Course { 1: i32 id, 2: string number, 3: string name, 4: Person instructor, 5: string roomNumber, 6: list<Person> students }
Here we have two more structs - Person and Course. Notice that these structs build on one another. The Person contains a list of Phones, while Course contains an instructor (one Person) and students (list of Persons). Thrift supports multiple collection types - list, set and map.
This completes the setup of our types. Let's move on to services.
service CourseService { list<string> getCourseInventory(), Course getCourse(1:string courseNumber) throws (1: CourseNotFound cnf), void addCourse(1:Course course) throws (1: UnacceptableCourse uc) void deleteCourse(1:string courseNumber) throws (1: CourseNotFound cnf) }
Here we have a defined a single service with 4 methods. Note that the arguments to service methods also require ordinals, just like structs. Also note that services can declare thrown exceptions and again each exception requires an ordinal:
exception CourseNotFound { 1: string message } exception UnacceptableCourse { 1: string message }
Before moving on to code generation, Thrift supports namespaces. For each namespace, you declare the language binding, as well as the namespace. In Java, this defines the package into which the generated code is created. The namespace declaration used in the example is below:
namespace java com.ociweb.jnb.thrift.gen namespace py com.ociweb.jnb.thrift
This completes our Thrift file.
Thrift supports many languages too varying degrees. The complete list is below. Be careful before assuming that just because your language has some support that it supports all of the features of Thrift. Python for instance, only supports TBinaryProtocol.
With this being the Java News Brief, this article will focus on the Java side of Thrift. Python will also be used in order to show how Thrift does indeed support cross-language development. The sample thrift file "course.thrift" used throughout this article requires the following invocations to generate Java and Python code, respectively:
The Thrift code generator is written in C++. Before running the Thrift code generation tool, you will need to build Thrift from source. If you don't care to bother for this article, simply skip this part and move on. The sample code has all you need to run the Java examples. If you decide to build it, the Thrift wiki has a page explaining this in sufficient detail (see references below).
The thrift code generator produces the following files for java and python, respectively:
|-- gen-java | `-- com | `-- ociweb | `-- jnb | `-- thrift | `-- gen | |-- Course.java | |-- CourseNotFoundException.java | |-- CourseService.java | |-- Person.java | |-- Phone.java | `-- UnacceptableCourseException.java `-- gen-py |-- __init__.py `-- com |-- __init__.py `-- ociweb |-- __init__.py `-- jnb |-- __init__.py `-- thrift |-- CourseService-remote |-- CourseService.py |-- __init__.py |-- constants.py `-- ttypes.py
Taking a look at the Java results, an individual file was created for each Thrift struct and exception, as you might expect. The senum thrift type did not result in a Java Enum as mentioned above, however. Rather, it resulted in a simple Java String inside the Phone class with a comment in the validate method stating that this is where the values for the type should be verified. Protocol Buffers on the other hand, did produce a Java Enum for the equivalent definition (see source for details). Lastly, a CourseService.java file was generated. This file contains classes to create clients and servers.
The Python results are again what you might expect. All the Thrift struct types as well as the exceptions are in the ttypes.py module, while the client and server code is in the CourseService.py module.
Creating a server in Thrift requires about the same amount of code as the other technologies examined in this article (REST and RMI). Check out the example code and judge for yourself. This example will use the TCompactProtocol with the FramedTransport and a non-blocking server. TFramedTransport is a requirement for using a non-blocking server, since the frames are used to determine when a given request is complete.
final TNonblockingServerSocket socket = new TNonblockingServerSocket(PORT); final CourseService.Processor processor = new CourseService.Processor( new Handler()); final TServer server = new THsHaServer(processor, socket, new TFramedTransport.Factory(), new TCompactProtocol.Factory()); server.serve(); ... private static class Handler implements CourseService.Iface { @Override public List<String> getCourseInventory() throws TException { return db.getCourseList(); } @Override public Course getCourse(String courseNumber) throws CourseNotFoundException, TException { final com.ociweb.jnb.thrift.db.Course dbCourse = db.getCourse(courseNumber); if (dbCourse != null) { return ConversionHelper.fromDbCourse(dbCourse); } return null; } @Override public void addCourse(Course course) throws UnacceptableCourseException, TException { com.ociweb.jnb.thrift.db.Course dbCourse = ConversionHelper.toDbCourse(course); db.addCourse(dbCourse); } @Override public void deleteCourse(String courseNumber) throws CourseNotFoundException, TException { if (db.getCourse(courseNumber) != null) { db.deleteCourse(courseNumber); } } }
The first few lines before the ellipsis simply setup the server with the protocol, transport and server type we want to use. The handler class is where the implementation of the services is done. There is a fictitious database referenced as "db" that is used for the calls to distill the code to its relevant parts and enable re-use for the comparisons later in this article.
Creating a Java client requires the same basic setup as the server, but does not require implementation of an interface.
//Setup the transport and protocol final TSocket socket = new TSocket(HOST, PORT); socket.setTimeout(SOCKET_TIMEOUT); final TTransport transport = new TFramedTransport(socket); final TProtocol protocol = new TCompactProtocol(transport); final CourseService.Client client = new CourseService.Client(protocol); //The transport must be opened before you can begin using transport.open(); //All hooked up, start using the service List<String> classInv = client.getCourseInventory(); System.out.println("Received " + classInv.size() + " class(es)."); client.deleteCourse("WINDOWS_301"); classInv = client.getCourseInventory(); System.out.println("Received " + classInv.size() + " class(es)."); transport.close();
The first few lines are the corollary to the setup of the server. The next several lines call the getCourseInventory and deleteCourse methods of the service. One thing to note is that while the server is using non-blocking IO, the client is using blocking IO. The equivalent non-blocking client socket was not fully implemented in the release build of Thrift that this example is built on. Each service operation actually calls send_<service-method> and recv_<service-method> method pairs internally. I tried calling these methods to see if I could get asynchronous behavior but had little luck. There is an "async" modifier that can be added to void return type methods, but the generated code looked no different with or without it. Finally, the generated receive methods don't gracefully return if no response was received when you do call them.
The Python client is effectively the same as the Java client except for syntax.
#Setup the transport and protocol socket = TSocket.TSocket("localhost", 8000) socket._timeout = 1000 transport = TTransport.TFramedTransport(socket) protocol_factory = TBinaryProtocol.TBinaryProtocolFactory() protocol = protocol_factory.getProtocol(transport) client = Client(protocol) #The transport must be opened before you can begin using transport.open() classInv = client.getCourseInventory() print "Received", len(classInv), "class(es)" client.deleteCourse("WINDOWS_301") classInv = client.getCourseInventory() print "Received", len(classInv), "class(es)"
Note that the Python code uses the TBinaryProtocol and not TCompactProtocol. The version of Thrift used for this article does not support TCompactProtocol for Python.
Both clients produce the following output against a newly started server:
Received 18 class(es). Received 17 class(es).
For more details on running the examples, see the README included with the source. For a quick start, simply run the following from the java directory:
In order to validate Thrift's value proposition, I decided to compare it with some other service technologies that are also fairly easy to use in practice. Since RESTful webservices seem to be popular of late, I have compared Thrift to REST. Although Protocol Buffers does not include a services infrastructure, it transports objects in a similar fashion to Thrift's TCompactProtocol, thus making it a useful comparison. Lastly, I included RMI, since it uses a binary transport and thus can serve as a "reference implementation" of sorts for Java binary object transport.
For the comparisons, I compared the file sizes and runtime performance of each service technology. For REST, I compared both XML-based and JSON-based REST. For Thrift, I chose the most efficient transport available for Java - TCompactProtocol.
To compare the sizes, I wrote out essentially the same data for each. Each write includes one Course object with 5 Person objects, and one Phone object. The definitions for each of these types can be seen in the thrift file listed above. To capture the file sizes, I used the following techniques:
|
The chart and table below show the results. Sizes are in bytes. None of the sizes include TCP/IP overhead.
|
|
|
*Smaller is better.
** Excludes messaging overhead. Includes only transported objects.
Thrift has a clear advantage in the size of its payload particularly compared to RMI and XML-based REST. Protocol Buffers from Google is effectively the same given that the Protocol Buffers number excludes messaging overhead.
To compare the runtime performance of Thrift, I created the following scenario:
Test Scenario
This scenario is executed 10,000 times. The tests were run on the following systems:
| Server | Client | |||||||||||||||||||||||||
|
|
The following table describes each test run:
|
*Since Protocol Buffers does not include a services infrastructure (unlike Thrift), I wrote my own server for this article.
The chart and table below summarize the results. All times are in seconds.
|
|
|
|
|
*Average Time excludes the first run in order to account for server warm-up. Smaller numbers are better.
The tests yielded some interesting observations. In terms of wall time Thrift clearly out-performed REST and RMI. In fact, TCompactProtocol took less than 20% of the time it took REST-XML to transmit the same data. The clear dominance of the binary protocols should not be too surprising, as binary data transmission is well-known to have higher performance than text-based protocols. RMI in fact significantly out-performed JSON-based REST in wall time, despite its significantly larger payload size (61.9% larger).
The CPU percentages yielded some interesting numbers. While the Thrift and Protocol Buffers servers had the highest server CPU percentages, the REST clients had the highest CPU percentages of the clients. For whatever reason Thrift and REST disproportionately place their CPU loads on their clients and servers. Protocol Buffers balanced its load most evenly between client and server, but then again this was a simple quick hand-rolled server that I wrote for this article. While I did not have time to analyze the cause of the CPU load, the Thrift and Protocol Buffers examples needed to do manual conversion of objects between what is transmitted and what is used. The RMI and REST implementations required no such object conversion. This extra bit of work may account for the additional CPU utilization on the Thrift and Protocol Buffers servers.
This test basically just covered throughput of each server. Another useful test would have been too test how each server handled multiple concurrent connections of shorter duration. There was insufficient time to complete a concurrent test for this article, however.
Given the poor performance of REST, there may certainly be higher performing servlet containers than Jetty that could be used as part of this test. Jetty was merely chosen because of its relative ease in implementation and ease in bundling for download of the sample code used in this article. Doing some quick searches, I found one performance comparison that showed Apache Tomcat to be faster than Jetty, and another that showed them at parity. Neither study showed anywhere near a performance difference to make up for the wall time performance of the binary protocols.
All of these technologies are roughly equivalent in the amount of coding complexity required to make them work. This excludes Protocol Buffers of course, as it contains no services infrastructure. It should also be noted that Thrift generates all the code you need for a client or server for each language it supports. Java was the server of choice in this article, but other languages could be used if they are better suited - one of the main reasons Thrift was developed in the first place. That being said, I found many of the implementations incomplete. As mentioned previously, the Python implmentation for instance only had the TBinaryProtocol implemented.
Thrift is a powerful library for creating high-performance services that can be called from multiple languages. If your application has a need for multiple languages to communicate where speed is a concern and your clients and servers are co-located, Thrift may well be the choice for you. Thrift might also make a good choice for IPC on a single machine where speed and/or interoperability are a concern.
Thrift was designed for use where clients and servers are co-located, as in a data center. If you consider using Thrift in environments where client and server are not co-located, you should expect to encounter some challenges. In particular, the aforementioned issue with asynchronous calls, as well as lack of security are likely to pose challenges. While the security issue may be solved by a new transport, the issue with asynchronous calls will likely require work in the core areas of Thrift. Plus, since Thrift supports numerous language bindings, you will likely need to make changes for each language you are using.
If the composite service work-around will not work for you, the server-per-service limitation in Thrift may pose a problem in some deployment scenarios. For instance, if the Thrift services are on one side of a firewall and the client's are on the other, some data centers may have a problem with opening up too many ports.
OCI is the leading provider of Object Oriented technology training in the Midwest. More than 3,000 students participated in our training program over the last 12 months. Targeted toward Software Engineers and the development community, our extensive program of over 50 hands-on workshops is delivered to corporations and individuals throughout the U.S. and internationally. OCI's Educational Services include Group Training events and Open Enrollment classes.
For further information regarding OCI's Educational Services programs, please visit our Educational Services section on this site or contact us at<EMAIL_ADDRESS>In order to help the client succeed, OCI offers a broad spectrum of services and solutions to our customers. Which services and solutions are appropriate for a particular client depend on the individual needs of the client, the details of the engagement, and the nature of the problem space.
OCI offers a variety of knowledge transfer services that include training, mentoring, and consulting. These can be used to quickly bring your existing staff up to speed on specific technologies and new products as well as entirely new software development approaches.
OCI uses and supports many different open source products and continually evaluates and adopts new products. For those products that we have developed or have become a core part of our business, we offer first class commercial support as well as services tailored to their adoption and deployment.
We are able to offer support for the customer in all phases of their software development, delivery, and deployment. Starting with Software Architecture support, we can help define the system, architecture, and associated development plan. We staff internal development centers that have the ability to deliver Turnkey solutions to your organization. We can also help augment your in-house development with Advantage IT Staffing solutions.
OCI helps organizations to integrate existing software systems as well as help architect and develop integrated "Systems of Systems".


public interface Replication
| Modifier and Type | Interface and Description |
|---|---|
static class |
Replication.Action |
static interface |
Replication.IDocumentOpenCallback
This function is called for each document retrieved.
|
static interface |
Replication.IFolderAddCallback
GetDocumentsMode.GET_FOLDER_ADDS is specified but GetDocumentsMode.APPLY_FOLDER_ADDS is not,
this function is called for each document after the Replication.IDocumentOpenCallback function is called |
static interface |
Replication.IGetDocumentsCallback
Called once before any others but only if going to a server that is R6 or greater.
|
static interface |
Replication.IObjectAllocCallback
If
GetDocumentsMode.SEND_OBJECTS is specified and objectDb is not NULL,
this function is called exactly once for each object to provide the caller with information
about the object's size and ObjectID. |
static interface |
Replication.IObjectWriteCallback
This function is called for each "chunk" of each object if
GetDocumentsMode.SEND_OBJECTS
is specified and objectDb is not NULL. |
static class |
Replication.ReplicationHistoryFlags
Optional flags that can be used with
getReplicationHistory(Database, Set) . |
| Modifier and Type | Field and Description |
|---|---|
static int |
REPLHIST_ONLY_COMPLETE
Only return complete entries
|
static int |
REPLHIST_REMOVE_WILDCARDS
Don't copy wild card entries
|
static int |
REPLHIST_SORT_BY_DATE
Sort by date.
|
| Modifier and Type | Method and Description |
|---|---|
void |
clearReplicationHistory(Database db)
Resets the replication history of a database so enforce a full replication
|
void |
getDocuments(Database db,
int[] noteIds,
Set<Database.OpenDocumentMode>[] docOpenFlags,
int[] sinceSeqNum,
Set<GetDocumentsMode> controlFlags,
Database objectDb,
Replication.IGetDocumentsCallback getDocumentsCallback,
Replication.IDocumentOpenCallback docOpenCallback,
Replication.IObjectAllocCallback objectAllocCallback,
Replication.IObjectWriteCallback objectWriteCallback,
TemporalAccessor folderSinceTime,
Replication.IFolderAddCallback folderAddCallback)
This function will return a stream of documents to the caller through several callback functions.
It can be used to quickly and incrementally read a large number of docs from a database, skipping the transfer of item values where the item's sequence number is lower or equal a specified value (see sinceSeqNum parameter). |
ReplicaInfo |
getReplicaInfo(Database db)
This function gets the given database's
ReplicaInfo structure.This structure contains information that tells the Domino Replicator how to treat the database. The ".ID" member enables the Replicator to identify "replicas" of databases. The ".CutoffInterval" is the age in days at which deleted document identifiers are purged. Domino divides this interval into thirds, and for each third of the interval carries out what amounts to an incremental purge. These deleted document identifiers are sometimes called deletion stubs. The ".Cutoff" member is a DominoDateTime value that is calculated by
subtracting the Cutoff Interval (also called Purge Interval) from today's date.It prevents notes that are older than that date from being replicated at all. The ".Flags" member is a bit-wise encoded short that stores miscellaneous Replicator flags. |
List<ReplicationHistorySummary> |
getReplicationHistory(Database db,
Set<Replication.ReplicationHistoryFlags> flags)
Reads the replication history of the database
|
void |
saveDocument(Document doc,
boolean force,
boolean noRevisionHistory,
boolean keepModTime)
Saves a document with additional flags
|
String |
setNewReplicaID(Database db)
Changes the replica id of a database
|
void |
setReplicaInfo(Database db,
ReplicaInfo replicaInfo)
This function sets the given database's
ReplicaInfo structure.Use this function to set specific values, such as the replica ID, in the header data of a database. You may also use setReplicaInfo(Database, ReplicaInfo) to set values
such as the replication flags in the header of the database. |
static final int REPLHIST_REMOVE_WILDCARDS
static final int REPLHIST_SORT_BY_DATE
static final int REPLHIST_ONLY_COMPLETE
List<ReplicationHistorySummary> getReplicationHistory(Database db, Set<Replication.ReplicationHistoryFlags> flags)
db
- databaseflags
- Optional history summary flags enabling you to specify that wildcard entries are not to be returned and/or that sorting is to be done by date rather than by the default, server namevoid clearReplicationHistory(Database db)
db
- databaseString setNewReplicaID(Database db)
db
- databaseReplicaInfo getReplicaInfo(Database db)
ReplicaInfo
structure.DominoDateTime
value that is calculated by
subtracting the Cutoff Interval (also called Purge Interval) from today's date.db
- databasevoid setReplicaInfo(Database db, ReplicaInfo replicaInfo)
ReplicaInfo
structure.setReplicaInfo(Database, ReplicaInfo)
to set values
such as the replication flags in the header of the database.db
- databasereplicaInfo
- new replica infovoid getDocuments(Database db, int[] noteIds, Set<Database.OpenDocumentMode>[] docOpenFlags, int[] sinceSeqNum, Set<GetDocumentsMode> controlFlags, Database objectDb, Replication.IGetDocumentsCallback getDocumentsCallback, Replication.IDocumentOpenCallback docOpenCallback, Replication.IObjectAllocCallback objectAllocCallback, Replication.IObjectWriteCallback objectWriteCallback, TemporalAccessor folderSinceTime, Replication.IFolderAddCallback folderAddCallback)
sinceSeqNum
parameter). In that case, items are returns with type ItemDataType.TYPE_UNAVAILABLE
db
- databasenoteIds
- note ID(s) of doc(s) to be retrieveddocOpenFlags
- flags that control the manner in which the document is opened. This, in turn, controls what information about the doc is available to you and how it is structured. The flags are defined in Database.OpenDocumentMode
and may be or'ed together to combine functionality.sinceSeqNum
- since sequence number; controls which fields are accessible in the returned documents; e.g. if you specify a very high value, items with lower or equal sequence number have the type ItemDataType.TYPE_UNAVAILABLE
controlFlags
- Flags that control the actions of the function during doc retrieval. The flags are defined in GetDocumentsMode
.objectDb
- If binary objects are being retrieved (GetDocumentsMode.SEND_OBJECTS
is used) and this value is not NULL, objects will be stored in this database and attached to the incoming docs prior to Replication.IDocumentOpenCallback
being called.getDocumentsCallback
- Called once before any others but only if going to a server that is R6 or greater. If GetDocumentsMode.ORDER_BY_SIZE
is specified in options totalSize provides the approximate total size of the bytes to be returned in the documents and objects. These values are intended to be used for progress indicationdocOpenCallback
- This function is called for each document retrieved. If non-NULL, this is called for each document after all objects have been retrieved (if GetDocumentsMode.SEND_OBJECTS
is specified)objectAllocCallback
- If GetDocumentsMode.SEND_OBJECTS
is specified and objectDb
is not NULL, this function is called exactly once for each object to provide the caller with information about the object's size and ObjectID. The intent is to allow for the physical allocation for the object if need be. It is called before the Replication.IDocumentOpenCallback
for the corresponding documentobjectWriteCallback
- This function is called for each "chunk" of each object if GetDocumentsMode.SEND_OBJECTS
is specified and objectDb
is not NULL. For each object this will be called one or more timesfolderSinceTime
- TemporalAccessor
containing a time/date value specifying the earliest time to retrieve documents from the folder. If GetDocumentsMode.GET_FOLDER_ADDS
is specified this is the time folder operations should be retrieved fromfolderAddCallback
- If GetDocumentsMode.GET_FOLDER_ADDS
is specified but GetDocumentsMode.APPLY_FOLDER_ADDS
is not, this function is called for each document after the Replication.IDocumentOpenCallback
function is calledvoid saveDocument(Document doc, boolean force, boolean noRevisionHistory, boolean keepModTime)
doc
- document to saveforce
- true to force document save even if the document was modified in the meantimenoRevisionHistory
- true to not update $RevisionskeepModTime
- true to not update the modified time of the documentCopyright © 2019–2021 HCL. All rights reserved.


The US president is chosen in two main steps. A national convention is held by each party fielding a candidate at which delegates from different states choose the candidate that will represent them in the wider, general election. The delegates themselves choose the candidates either through caucus or primary elections (please see Votesmart.org for more details).
Several candidates compaign to be the party nominee for the general election prior to the national convention. After the national convention each party has only one candidate for the general election.
While there is no constitutional mandate restricting the number of parties, the US is mostly under a two party system, though third parties and independent candidates frequently emerge historically with limited impact. There is the Republican Party leaning on a right wing, conservative political platform. The Democratic Party leans on the more progressive left wing of the political spectrum.
As of end of April 2016 more than 80% of national delegates had already chosen through the caucases and primaries affiliation with a particular candidate. Hillary R. Clinton and Donald J. Trump lead the tickets for the Democratic and Republican Parties respectively.
This project depicts the prevailing sentiment for the candidates as gleaned from nationwide tweets (on Twitter) about the two leading candidates. The analysis is concurrent and emphasizes a comparative snapshot rather than an aggregate of sentiment.
(image courtesy of The Economist in this article )
Trump's Speech in Buffalo
This data vizualization project is the work Howard Wen, Dhaval Bhatt and Happiness Munedzimwe as a term project for the class DW209 Data Visualization offered by UC Berkeley under the Master of Information and Data Science (MIDS) program at UC Berkeley. Please contact us with any comments, concerns or requests.


{{didId}}
Nickname
{{nickname}}
Type
{{managementKey.type}}
Controller
{{minDid(managementKey.controller)}}
Public Key
{{minKey(managementKey.publicKey)}}
Priority
{{managementKey.priority}}
Priority Requirement
{{managementKey.priorityRequirement !== null ? managementKey.priorityRequirement : 'N/A'}}
The Identity does not have any Signing Keys
Service type
{{service.type}}
Alias
{{service.alias}}
Service endpoint
{{service.endpoint}}
Priority Requirement
{{service.priorityRequirement !== null ? service.priorityRequirement : 'N/A'}}
The Identity does not have any Services


| Package | Description |
|---|---|
| org.antlr.v4.runtime | |
| org.antlr.v4.runtime.atn | |
| org.antlr.v4.runtime.tree.pattern | |
| org.antlr.v4.runtime.tree.xpath |
| Modifier and Type | Class and Description |
|---|---|
class |
ANTLRFileStream
Deprecated.
as of 4.7 Please use
CharStreams interface. |
class |
ANTLRInputStream
Deprecated.
as of 4.7 Please use
CharStreams interface. |
class |
CodePointCharStream
Alternative to
ANTLRInputStream which treats the input
as a series of Unicode code points, instead of a series of UTF-16
code units. |
class |
UnbufferedCharStream
Do not buffer up the entire char stream.
|
| Modifier and Type | Field and Description |
|---|---|
CharStream |
Lexer._input |
| Modifier and Type | Field and Description |
|---|---|
protected Pair<TokenSource,CharStream> |
Lexer._tokenFactorySourcePair |
protected static Pair<TokenSource,CharStream> |
CommonToken.EMPTY_SOURCE
An empty
Pair which is used as the default value of
CommonToken.source for tokens that do not have a source. |
protected Pair<TokenSource,CharStream> |
CommonToken.source
This is the backing field for
CommonToken.getTokenSource() and
CommonToken.getInputStream() . |
| Modifier and Type | Method and Description |
|---|---|
static CharStream |
CharStreams.fromChannel(ReadableByteChannel channel)
Creates a
CharStream given an opened ReadableByteChannel
containing UTF-8 bytes. |
static CharStream |
CharStreams.fromChannel(ReadableByteChannel channel,
Charset charset)
Creates a
CharStream given an opened ReadableByteChannel and the
charset of the bytes contained in the channel. |
static CharStream |
CharStreams.fromFileName(String fileName)
Creates a
CharStream given a string containing a
path to a UTF-8 file on disk. |
static CharStream |
CharStreams.fromFileName(String fileName,
Charset charset)
Creates a
CharStream given a string containing a
path to a file on disk and the charset of the bytes
contained in the file. |
static CharStream |
CharStreams.fromPath(Path path)
Creates a
CharStream given a path to a UTF-8
encoded file on disk. |
static CharStream |
CharStreams.fromPath(Path path,
Charset charset)
Creates a
CharStream given a path to a file on disk and the
charset of the bytes contained in the file. |
static CharStream |
CharStreams.fromStream(InputStream is)
Creates a
CharStream given an opened InputStream
containing UTF-8 bytes. |
static CharStream |
CharStreams.fromStream(InputStream is,
Charset charset)
Creates a
CharStream given an opened InputStream and the
charset of the bytes contained in the stream. |
static CharStream |
CharStreams.fromStream(InputStream is,
Charset charset,
long inputSize) |
CharStream |
TokenSource.getInputStream()
Get the
CharStream from which this token source is currently
providing tokens. |
CharStream |
Token.getInputStream()
Gets the
CharStream from which this token was derived. |
CharStream |
ListTokenSource.getInputStream()
Get the
CharStream from which this token source is currently
providing tokens. |
CharStream |
LexerNoViableAltException.getInputStream() |
CharStream |
Lexer.getInputStream() |
CharStream |
CommonToken.getInputStream() |
| Modifier and Type | Method and Description |
|---|---|
Symbol |
TokenFactory.create(Pair<TokenSource,CharStream> source,
int type,
String text,
int channel,
int start,
int stop,
int line,
int charPositionInLine)
This is the method used to create tokens in the lexer and in the
error handling strategy.
|
CommonToken |
CommonTokenFactory.create(Pair<TokenSource,CharStream> source,
int type,
String text,
int channel,
int start,
int stop,
int line,
int charPositionInLine) |
| Constructor and Description |
|---|
Lexer(CharStream input) |
LexerInterpreter(String grammarFileName,
Collection<String> tokenNames,
Collection<String> ruleNames,
Collection<String> modeNames,
ATN atn,
CharStream input)
Deprecated.
|
LexerInterpreter(String grammarFileName,
Vocabulary vocabulary,
Collection<String> ruleNames,
Collection<String> modeNames,
ATN atn,
CharStream input)
Deprecated.
|
LexerInterpreter(String grammarFileName,
Vocabulary vocabulary,
Collection<String> ruleNames,
Collection<String> channelNames,
Collection<String> modeNames,
ATN atn,
CharStream input) |
LexerNoViableAltException(Lexer lexer,
CharStream input,
int startIndex,
ATNConfigSet deadEndConfigs) |
| Constructor and Description |
|---|
CommonToken(Pair<TokenSource,CharStream> source,
int type,
int channel,
int start,
int stop) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
LexerATNSimulator.accept(CharStream input,
LexerActionExecutor lexerActionExecutor,
int startIndex,
int index,
int line,
int charPos) |
protected void |
LexerATNSimulator.captureSimState(LexerATNSimulator.SimState settings,
CharStream input,
DFAState dfaState) |
protected boolean |
LexerATNSimulator.closure(CharStream input,
LexerATNConfig config,
ATNConfigSet configs,
boolean currentAltReachedAcceptState,
boolean speculative,
boolean treatEofAsEpsilon)
Since the alternatives within any lexer decision are ordered by
preference, this method stops pursuing the closure as soon as an accept
state is reached.
|
protected ATNConfigSet |
LexerATNSimulator.computeStartState(CharStream input,
ATNState p) |
protected DFAState |
LexerATNSimulator.computeTargetState(CharStream input,
DFAState s,
int t)
Compute a target state for an edge in the DFA, and attempt to add the
computed state and corresponding edge to the DFA.
|
void |
LexerATNSimulator.consume(CharStream input) |
protected boolean |
LexerATNSimulator.evaluatePredicate(CharStream input,
int ruleIndex,
int predIndex,
boolean speculative)
Evaluate a predicate specified in the lexer.
|
protected int |
LexerATNSimulator.execATN(CharStream input,
DFAState ds0) |
void |
LexerActionExecutor.execute(Lexer lexer,
CharStream input,
int startIndex)
Execute the actions encapsulated by this executor within the context of a
particular
Lexer . |
protected int |
LexerATNSimulator.failOrAccept(LexerATNSimulator.SimState prevAccept,
CharStream input,
ATNConfigSet reach,
int t) |
protected LexerATNConfig |
LexerATNSimulator.getEpsilonTarget(CharStream input,
LexerATNConfig config,
Transition t,
ATNConfigSet configs,
boolean speculative,
boolean treatEofAsEpsilon) |
protected void |
LexerATNSimulator.getReachableConfigSet(CharStream input,
ATNConfigSet closure,
ATNConfigSet reach,
int t)
Given a starting configuration set, figure out all ATN configurations
we can reach upon input
t . |
String |
LexerATNSimulator.getText(CharStream input)
Get the text matched so far for the current token.
|
int |
LexerATNSimulator.match(CharStream input,
int mode) |
protected int |
LexerATNSimulator.matchATN(CharStream input) |
| Modifier and Type | Method and Description |
|---|---|
CharStream |
RuleTagToken.getInputStream()
Gets the
CharStream from which this token was derived. |
| Constructor and Description |
|---|
XPathLexer(CharStream input) |
Copyright © 1992–2021 ANTLR. All rights reserved.


2. Install Juju¶
Juju is an open source application modelling tool that allows you to deploy, configure, scale and operate your software on public and private clouds.
In the previous step, we installed, deployed and configured MAAS to use as a foundation for Juju to deploy a fully fledged OpenStack cloud.
We are now going to install and configure the following two core components of Juju to use our MAAS deployment:
- The controller is the management node for a cloud environment. We will be using the MAAS node we tagged with juju to host the Juju controller.
- The client is used by the operator to talk to one or more controllers, managing one or more different cloud environments. As long as it can access the controller, almost any machine and operating system can run the Juju client.
2.1. Package installation¶
We’re going to start by installing the Juju client on a machine running Ubuntu 16.04 LTS (Xenial) with network access to the MAAS deployment. For other installation options, see Getting started with Juju. To install Juju, enter the following in the terminal:
sudo add-apt-repository -u ppa:juju/stable
sudo apt install juju
2.2. Client configuration¶
The Juju client needs two pieces of information before it can control our MAAS deployment.
- A cloud definition for the MAAS deployment. This definition will include where MAAS can be found and how Juju can authenticate itself with it.
- A separate credentials definition that’s used when accessing MAAS. This links the authentication details to the cloud definition.
To create the cloud definition, type juju add-cloud mymaas
to add a cloud called mymaas. This will produce output similar to the following:
Cloud Types
maas
manual
openstack
vsphere
Select cloud type:
Enter maas
as the cloud type and you will be asked for the API endpoint URL. This URL is the same as the URL used to access the MAAS web UI in the previous step: http://<your.maas.ip>:5240/MAAS/.
With the endpoint added, Juju will inform you that mymass was successfully added. The next step is to add credentials. This is initiated by typing juju add-credential mymaas
. Enter admin
when asked for a credential name.
Juju will output the following:
Enter credential name: admin
Using auth-type "oauth1".
Enter maas-oauth:
The oauth1 credential value is the MAAS API key for the admin user. To retrieve this, login to the MAAS web UI and click on the admin username near the top right. This will show the user preferences page. The top field will hold your MAAS keys:
Copy and paste this key into the terminal and press return. You will be informed that credentials have been added for cloud mymaas.
You can check the cloud definition has been added with the juju clouds
command, and you can list credentials with the juju credentials
command.
2.3. Testing the environment¶
The Juju client now has everything it needs to instruct MAAS to deploy a Juju controller.
But before we move on to deploying OpenStack, it’s worth checking that everything is working first. To do this, we’ll simply ask Juju to create a new controller for our cloud:
juju bootstrap --constraints tags=juju mymaas maas-controller
The constraint in the above command will ask MAAS to use any nodes tagged with juju to host the controller for the Juju client. We tagged this node within MAAS in the previous step.
The output to a successful bootstrap will look similar to the following:
Creating Juju controller "maas-controller" on mymaas
Looking for packaged Juju agent version 2.2-alpha1 for amd64
Launching controller instance(s) on mymaas...
- 7cm8tm (arch=amd64 mem=2G cores=2)
Fetching Juju GUI 2.4.4
Waiting for address
Attempting to connect to <IP_ADDRESS>:22
Bootstrap agent now started
Contacting Juju controller at <IP_ADDRESS> to verify accessibility...
Bootstrap complete, "maas-controller" controller now available.
Controller machines are in the "controller" model.
Initial model "default" added.
If you’re monitoring the nodes view of the MAAS web UI, you will notice that the node we tagged with juju starts deploying Ubuntu 16.04 LTS automatically, which will be used to host the Juju controller.
2.4. Next steps¶
We’ve now installed the Juju client and given it enough details to control our MAAS deployment, which we’ve tested by bootstrapping a new Juju controller. The next step will be to use Juju to deploy and link the various components required by OpenStack.


Broadcast, cable networks to televise impeachment hearings
by EndPlayNEW YORK (AP) - ABC, CBS, NBC and PBS will set aside scheduled programming next week to cover the House's first open impeachment hearings on President Trump.
The cable news networks CNN, Fox News Channel, MSNBC and CSPAN will also provide live coverage. The broadcast networks' announcement Friday that they would televise the hearing, however, gives the event an extra measure of exposure and weight with the public.
The first hearing of the House intelligence committee's hearing is scheduled for 10 a.m. Eastern on Wednesday, with the second on Friday at 11 a.m.
William Taylor, the U.S. diplomat in the Ukraine, is scheduled to testify Wednesday about the Trump administration's efforts to tie U.S. military aid to that country in an agreement to investigate the president's political rivals.


Your browser does not support HTML5 audio!
Alarm Clock
Countdown Timer
12-hour
24-hour
Hour
Minute
Snooze
Stop
Created by
Jonathan Sharman
.


Postgre for database for entity framework
Reactjs for frontend (Formik, ReduxForm, lodash library, Less, Saas, wepback, wrappers, hooks, Redux)
Axios for restful Apis
Django python for web framework
Familiarity with graph ql
Familiarity with Firebase real time database
GUN as an offline database
Socket io and lowdb for sync data
Deal with excel export and import json
Jest and ezyme for unit test
Postgre for database for entity framework
Reactjs for frontend (Formik, ReduxForm, lodash library, Less, Saas, wepback, wrappers, hooks, Redux)
Axios for restful Apis
Django python for web framework
Familiarity with graph ql
Familiarity with Firebase real time database
GUN as an offline database
Socket io and lowdb for sync data
Deal with excel export and import json
Jest and ezyme for unit test
React Js for frontend (React Hook Form, lodash library, Saas, Hooks, Redux Toolkit)
Axios for restful Apis
Django python for web framework
Matrial UI
Date-time fns
I'm Merna Samir Mosaad Graduated from Computer Science Ain Shams since 2018 I have 3 years work experience in frontend development field i can learn new technologies in short time i also have strong knowledge in Reactjs formik, less ,moment ,axios, hooks, react hook form, toolkit redux, lodash, redux , redux toolkit, sagas i have basics in angular, I am self confident , hard worker , self motivated person
Download Resume


Spinal Tap
After their highly-publicized search for a new drummer, Spinal Tap kicks off their latest comeback tour with a San Francisco show.
When:
Oct 15, 7:00PM
-
9:00PM
Where:
Warfield Theatre,
982 Market St,
San Francisco,
CA
Spinal Tap 4
After their highly-publicized search for a new drummer, Spinal Tap kicks off their latest comeback tour with a San Francisco show.
When:
Oct 15, 7:00PM
-
9:00PM
Where:
San Jose,
1053 B, Alta Mira Drive,
Santa Clara,
CA


A-Plan
Log In
Sign Up
About Us
Course Catalogue
My Page
Register
Select Your Major
Computer Science
Business Technology Management
Computer Engineering
Biomolecular Science
Chemical&Biological Engineering
Civil Engineering
Culture, Arts, and Media
Electrical Engineering
Integrated Digital Media
Mathematics
Mechanical Engineering
Physics
Science and Technology
Society, Environment&Globalization
Urban Studies
Register


It’s a simple truth that death is a natural part of life. However, death becomes an unnatural criminal act when a person’s life is cut short due to the negligent act or decision of another. Murder, homicide, gross negligence and unforeseen accidents are all causes of wrongful deaths.
Through legal action, it is possible for families to not only gain closure and a sense of justice, but also financial compensation for past, current, and future expenses. Common types of economic and non-economic damages that may be awarded in an Arizona wrongful death case include:
Every case is unique and a jury will determine the amount of damages that may be awarded based on the circumstances of the victim's death, the victim's income and expected future earnings, and the non-economic losses suffered by each eligible survivor.
When a person passes away, it is likely that many lives will be affected by the loss and in some cases, experience economic consequences. However, not everyone is entitled to sue the at-fault party for damages. In Arizona, the surviving spouse, children, parents, or guardian of a deceased person may lawfully pursue a wrongful death claim. A lawyer will act on behalf of the survivors, also known as beneficiaries, to ensure that the case is both uncomplicated and efficient, especially if there are several family members involved.
In Arizona, survivors must file a wrongful death claim within two years of the death in order to be eligible for compensation. Failure to take legal action within the statute of limitations can result in the loss of right to assert a wrongful death claim. While a statute of limitations is generally strict, there are unique circumstances in which an individual may be able to file a claim after the specific time period has expired. An experienced and knowledgeable lawyer will be able to evaluate your case and determine whether you still have a potential claim.
The compassionate Scottsdale personal injury legal team at Goldman Accident Lawyers understands the needs of a grieving family, and will work tirelessly to ensure that you gain the compensation you need and deserve. With years of experience defending clients who have suffered emotional and financial losses as the result of another's negligent actions or wrongdoing. Please do not hesitate to contact us to learn more about your options for recovery.


{{title}}
Old Mill Cafe, Coast Road, Bardsea, Ulverston, Cumbria, LA12 9RB
| Effective date | Rateable value | Capacity | From | To | Actions |
|---|---|---|---|---|---|
| 1 Apr 2010 | £28500 | Owner | 1 Apr 2017 | Present |
| Effective date | Rateable value | Capacity | From | To | Actions |
|---|---|---|---|---|---|
| 1 Apr 2010 | £28500 | Owner | 1 Apr 2017 | Present |


When
Monday, September 30, 2019 3:30 PM – 4:30 PM
When
Wednesday, October 2, 2019 10:45 AM – 11:45 AM
When
Tuesday, October 8, 2019 11:30 AM – 12:30 PM
When
Friday, October 11, 2019 10:30 AM – 11:30 AM
When
Thursday, October 17, 2019 10:40 AM – 11:40 AM


So much of our lives centers around coordinating in groups. For instance, we are able to coordinate with and influence groups of people both implicitly (e.g. when sharing lanes on the highway) and explicitly (e.g. when cooking a meal together). As robots become increasingly integrated into society, they should be able to similarly coordinate well with human groups.
Examples of group coordination include collaborative cooking, protesting, and navigating crowded spaces.
However, influencing groups of people is challenging. For example, imagine a volunteer search and rescue mission where a drone learns new information about the location of a target (depicted as the blue checkmark below). Assuming that there is no direct mode of communication available, how should the drone lead a team of volunteers toward that location?
The blue arrow represents the desired path and the red arrow represents the current sub-optimal path of the human volunteers.
One way a drone could lead the team would be to model and influence each individual separately. By modeling, we mean understanding and predicting a person’s behavior. However, modeling and influencing people independently of one another does not scale well with larger numbers of individuals and is something that we cannot compute quickly online.
A drone modeling each volunteer individually. This approach doesn't scale well with larger numbers of agents.
Another way to influence a team of humans would be to forgo any modeling and directly learn a policy, or an action plan, from observations of the team. This method provides a plausible solution for teams of a constant size. However, adding or subtracting a team member can change the model’s input size and will require you to re-train your model.
Thus our goal is to develop a framework that enables robots to model and influence human groups and is scalable with the number of human agents.
Our contributions are as follows:
- We introduce a way we can model group interactions in a scalable way.
- We describe how a robot can use this knowledge to influence human teams.
Latent structures in human groups
Instead of modeling each individual in a group, our key idea is to focus on modeling relations among individuals. When we interact in groups, we no longer act in isolation but instead act conditionally based on others’ actions. These dependencies provide structure which we can then use to form expectations of others and behave accordingly. On a larger scale, this allows us to develop norms, conventions, and even cultures. These dependencies are useful for robots because they provide a rich source of information that can help robots model and predict human behavior. We call these dependencies latent structures.
Different driving cultures that have been developed in Japan (left) and India (right).
An important example of latent structures is leading and following behavior. We can easily form teams and decide if we should follow or lead to efficiently complete a task as a group. For instance, in a search and rescue mission, humans can spontaneously become leaders once they discover new information about a target. We also implicitly coordinate leading and following strategies. For example, drivers follow each other across lanes when driving through traffic. We focus on modeling latent leading and following structures as a running example in our work.
Examples of latent leading and following structures among volunteers in a search and rescue mission (left), and cars following each other through traffic (right).
So how do we actually go about modeling these latent structures? And what properties should our ideal model have? Before we get into how we can model latent structures, let’s establish some desiderata:
- Complexity: Since these structures are often implicitly formed, our model should be complex enough to capture complicated relationships among individuals.
- Scalability: We should be able to use our model with changing numbers of agents.
Modeling latent structures
The simplest case
We use a supervised learning approach to estimate relationships between two human agents. Going back to our desiderata, this addresses the issue of complexity because using a learning-based approach allows us to capture complex relationships the pair might have. Using a simulator, we can ask participants to demonstrate the desired relationship we want to measure, such as leading and following.
We abstract the search and rescue mission into a game where goals represent potential survivor locations. In the example below, participants were asked to lead and follow each other in order to collectively decide on a goal to arrive at. Human data is often noisy and difficult to collect in bulk. To make up for these factors, we augmented our dataset with simulated human data. We can then feed this data into neural network modules that are trained to predict leading and following relationships. This gives us a model that can score how likely each agent and goal is to be an agent’s leader.
The network predicts that player 2's leader is player 1.
Scaling up
Now, how can we model a much larger team? Using our model from above, we can represent relationships among multiple humans as a graph by computing scores for pairwise relationships between all agents and goals. Each edge depicted has a probability assigned to it by our trained neural network (probabilities are abstracted away in the graphic below).
We compute pairwise weights of leader-follower relationships between all possible pairs of leaders and followers.
We can then solve for a maximum likelihood graph by pruning the original graph using graph-theoretic algorithms. For instance, we can greedily select the outgoing edge with the highest weight for each agent.
We are left with a graph where the bold edges represent the most likely edges. We call this graph the leader-follower graph (LFG).
Leader-follower graph (LFG). We can use the LFG to identify the most influential leader, the agent with the greatest number of followers.
The graph structure is scalable with the number of agents since we can easily model changing numbers of agents in real-time. For instance, adding an agent in the next $kth$ timestep takes linear time with respect to the number of agents $n$ and the number of goals $m$. In practice, this takes on the order of milliseconds to compute.
How accurately does our model generalize?
We evaluated how accurately our model generalizes by comparing the predictions made by our leader-follower graph against ground truth predictions. We experimented with training with simulated data and data that contains both simulated and real human data (mixed data). We find that training with larger numbers of players helps with generalization. This suggests that there is a tradeoff between training with smaller numbers of humans and larger numbers (which requires you to collect more data).
How are latent structures useful for robots?
Robots can use latent structures to infer useful information about a team. For instance, in the leading and following example, we can identify information such as agents’ goals or who the most influential leader is. These pieces of information allow the robot to identify key goals or agents that are critical to the task. With this in mind, the robot can then take actions to achieve a desired outcome. Here are two tasks where the robot uses the graph structure to influence human teams:
A. Collaborative task
Being able to lead a team of humans to a goal is useful in many real-life scenarios. For instance, in search-and-rescue missions, robots with more information about the location of survivors should be able to lead the team. We’ve created a similar scenario where there are two goals, or potential locations of survivors, and a robot that knows which location the survivors are at. The robot tries to maximize joint utility by leading all of its teammates to reach the target location. To influence the team, the robot uses the leader-follower graph to infer who the current most influential leader is. The robot then selects actions that maximize the probability of the most influential leader reaching the optimal goal.
In the graphics below, the green circles represent locations (or goals), orange circles are simulated human agents and black circle is the robot. The robot is trying to lead the team towards the more optimal bottom location. We contrast a robot using our graph structure (left) with a robot that greedily targets the optimal goal (right).
The robot succeeds if the majority of humans collide with the bottom goal first, and fails if the majority collide with the sub-optimal goal. Here is a chart documenting the success rate of a robot using the graph representation compared to a robot using other baseline policies.
Success rate over 100 collaborative games with n=4 players and varying number of goals
We find that our graphical representation is helpful in more difficult scenarios with larger numbers of potential goals.
B. Adversarial task
A robot might also want to prevent a team of humans from reaching a collective goal. For instance, imagine a capture-the-flag game where a robot teammate is trying to prevent the opposing team from capturing any flags.
We’ve created a similar task where a robot wants to prevent a team of humans from reaching a goal. In order to stall the team, the adversarial robot uses the leader-follower graph to identify who the current most influential leader is. The robot then selects actions that maximize the probability of the robot leading the inferred most influential leader away from the goals. An example of the robot’s actions are shown below on the left. On the right, we show an example of a simple policy where a robot randomly chooses one player and unsuccessfully tries to block it.
By preventing players from reaching a goal, the robot is trying to extend game time as much as possible. Here is a graph of a robot using our graph representation compared to other baseline policies.
Two policies using the leader-follower graph (LFG) successfully extend game time better than other baseline approaches.
We find that a robot using our graphical representation is the most successful at extending game time compared to other baseline policies.
What’s next?
We’ve introduced a scalable way we can represent inherent structures in human teams. We then demonstrated how we can use this structure to design intelligent influencing behaviors. For future work, we’re interested in a couple of things:
- Real-world experiments. We’re implementing our algorithms on miniature swarm robots so we can conduct human-robot teaming experiments with real robots and humans.
- Varying domains and structures. It would be nice to test our framework on more types of latent structures (e.g., how teammates trust one another) and in different domains (e.g., driving, partially observable settings).
To learn more, please check out the following paper this post was based on:
Influencing Leading and Following in Human-Robot Teams (pdf) Minae Kwon*, Mengxi Li*, Alexandre Bucquet, Dorsa Sadigh Proceedings of Robotics: Science and Systems (RSS), June 2019
* denotes equal contribution, and the order of the authors was chosen randomly


aireplay-ng
Inject packets into a wireless network.
Part of `aircrack-ng`.
More information: home page
- Send a specific number of disassociate packets given an access point's MAC address, a client's MAC address and an interface:
sudo aireplay-ng --deauth count --bssid ap_mac --dmac client_mac interface


您的浏览器已禁用 JavaScript。
跳过导航链接
概览
程序包
类
树
已过时
索引
帮助
上一个
下一个
框架
无框架
所有类
程序包io.ktor.routing的分层结构
程序包分层结构:
所有程序包
类分层结构
io.ktor.routing.
RouteSelector
io.ktor.routing.
AndRouteSelector
io.ktor.routing.
ConstantParameterRouteSelector
io.ktor.routing.
HttpAcceptRouteSelector
io.ktor.routing.
HttpHeaderRouteSelector
io.ktor.routing.
HttpMethodRouteSelector
io.ktor.routing.
OptionalParameterRouteSelector
io.ktor.routing.
OrRouteSelector
io.ktor.routing.
ParameterRouteSelector
io.ktor.routing.
PathSegmentConstantRouteSelector
io.ktor.routing.
PathSegmentOptionalParameterRouteSelector
io.ktor.routing.
PathSegmentParameterRouteSelector
io.ktor.routing.
PathSegmentTailcardRouteSelector
io.ktor.routing.
PathSegmentWildcardRouteSelector
io.ktor.routing.
RoutingBuilderKt
io.ktor.routing.
Routing.Feature
(implements io.ktor.application.
ApplicationFeature
<TPipeline,TConfiguration,TFeature>)
io.ktor.application.
ApplicationCallPipeline
io.ktor.routing.
Route
io.ktor.routing.
Routing
io.ktor.routing.
RoutingApplicationResponse
(implements io.ktor.response.
ApplicationResponse
)
io.ktor.routing.
PathSegmentSelectorBuilder
io.ktor.routing.
RouteSelectorEvaluation
io.ktor.routing.
RoutingPathSegment
io.ktor.routing.
RoutingKt
io.ktor.routing.
RoutingResolveResult
io.ktor.routing.
RoutingResolveContext
io.ktor.routing.
RoutingApplicationCall
(implements io.ktor.application.
ApplicationCall
)
io.ktor.routing.
RoutingApplicationRequest
(implements io.ktor.request.
ApplicationRequest
)
io.ktor.routing.
RouteSelectorEvaluation.Companion
io.ktor.routing.
RoutingPath
io.ktor.routing.
RoutingPath.Companion
枚举分层结构
io.ktor.routing.
RoutingPathSegmentKind
跳过导航链接
概览
程序包
类
树
已过时
索引
帮助
上一个
下一个
框架
无框架
所有类


Library App
Add a New Book
Title
Author
Pages
Have you read the book?
Submit
Cancel
Title
Author
Pages
Completed


|
i2cpwm_board
0.5.1
ROS Package for PCA9685 based 16 channel PWM Board with I2C Interface
|
controller for I2C interfaced 16 channel PWM boards with PCA9685 chip More...
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <linux/i2c-dev.h>
#include <ros/ros.h>
#include <ros/console.h>
#include <std_srvs/Empty.h>
#include <geometry_msgs/Twist.h>
#include "i2cpwm_board/Servo.h"
#include "i2cpwm_board/ServoArray.h"
#include "i2cpwm_board/ServoConfig.h"
#include "i2cpwm_board/ServoConfigArray.h"
#include "i2cpwm_board/ServosConfig.h"
#include "i2cpwm_board/DriveMode.h"
#include "i2cpwm_board/Position.h"
#include "i2cpwm_board/PositionArray.h"
#include "i2cpwm_board/IntValue.h"
Go to the source code of this file.
Functions | |
| void | servos_absolute (const i2cpwm_board::ServoArray::ConstPtr &msg) |
| subscriber topic to move servos in a physical position More... | |
| void | servos_proportional (const i2cpwm_board::ServoArray::ConstPtr &msg) |
| subscriber topic to move servos in the range of ±1.0 More... | |
| void | servos_drive (const geometry_msgs::Twist::ConstPtr &msg) |
| subscriber topic to move servos based on a drive mode More... | |
| bool | set_pwm_frequency (i2cpwm_board::IntValue::Request &req, i2cpwm_board::IntValue::Response &res) |
| service to set set PWM frequency More... | |
| bool | config_servos (i2cpwm_board::ServosConfig::Request &req, i2cpwm_board::ServosConfig::Response &res) |
| store configuration data for servos on the active board More... | |
| bool | config_drive_mode (i2cpwm_board::DriveMode::Request &req, i2cpwm_board::DriveMode::Response &res) |
| set drive mode and drive servos More... | |
| bool | stop_servos (std_srvs::Empty::Request &req, std_srvs::Empty::Response &res) |
| service to stop all servos on all boards More... | |
controller for I2C interfaced 16 channel PWM boards with PCA9685 chip
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
Please send comments, questions, or patches to info@ brad anlan e.co m
Definition in file i2cpwm_controller.cpp.


Every day is taco ipsum tuesday. Tacos dorados called flautas, or taquitos, for which the tortillas are filled with pre-cooked shredded chicken, beef or barbacoa, rolled into an elongated cylinder and deep-fried until crisp. CARNITAS!! Give me all the tacos, immediately. Um, Tabasco? No thanks, do you have any Cholula? Black or pinto beans? 50 cent tacos! I’ll take 30. Side of rice and beans, please. BARBACOA!! Make it a double there pal.  Shrimp tacos are tasty tacos!
Tacos Al pastor/De Adobada are made of thin pork steaks seasoned with adobo seasoning, then skewered and overlapped on one another on a vertical rotisserie cooked and flame-broiled as it spins. It’s raining tacos, from out of the sky, tacos, don’t even ask why. Can you put some peppers and onions on that? CARNE ASADA!! Carne asada on corn tortillas. Let’s do a beef and a chicken, and one with both. How do you feel about hard shelled tacos? Does guac cost extra? Give me all the tacos, immediately.
It’s taco time all the time. Black or pinto beans? How bout a gosh darn quesadilla? Tacos dorados called flautas, or taquitos, for which the tortillas are filled with pre-cooked shredded chicken, beef or barbacoa, rolled into an elongated cylinder and deep-fried until crisp. I think I’ve overdosed on tacos. Um, Tabasco? No thanks, do you have any Cholula? Pico de gallo, on the side please. Say taco one more time. Tacos, tacos, tacos. Burritos are very tasty. Give me all your tacos.


 These may be signs of a serious condition. See your doctor.
- if you have kidney disease, except under the advice and supervision of a doctor
- with other acid reducers
Ask a doctor before use if you have
- had heartburn over 3 months. This may be a sign of a more serious condition.
- heartburn with lightheadedness, sweating, or dizziness
- chest pain or shoulder pain with shortness of breath; sweating; pain spreading to arms, neck or shoulders; or lightheadedness
- frequent chest pain
- frequent wheezing, particularly with heartburn
- unexplained weight loss
- nausea or vomiting
- stomach pain
Stop use and ask a doctor if
- your heartburn continues or worsens
- you need to take this product for more than 14 days
If pregnant or breast-feeding, ask a health professional before use.
Keep out of reach of children. In case of overdose, get medical help or contact a Poison Control Center right away.
Directions
- adults and children 12 years and over:
- to relieve symptoms, swallow 1 tablet with a glass of water. Do not chew.
- to prevent symptoms, swallow 1 tablet with a glass of water at any time from 10 to 60 minutes before eating food or drinking beverages that cause heartburn
- do not use more than 2 tablets in 24 hours
- children under 12 years: ask a doctor
Other information
- read the directions and warnings before use
- keep the carton. It contains important information.
- store at 20°-25°C (68°-77°F)
- protect from moisture
Inactive ingredients
carnauba wax, hydroxypropyl cellulose, hypromellose, magnesium stearate, microcrystalline cellulose, pregelatinized starch, talc, titanium dioxide
Questions or comments?
1-800-755-4008 (toll-free) or<PHONE_NUMBER> (collect)
PRINCIPAL DISPLAY PANEL
NDC 16837-855-14
MAXIMUM STRENGTH
Pepcid®
AC®
Famotidine Tablets 20 mg
Acid Reducer
Just One Tablet!
Prevents & Relieves Heartburn
Due to Acid Indigestion
25 Tablets
McNeil Consumer Pharmaceuticals Co.


Mitchell Johnson
ehntoo@ehntoo.org(616) 432-0456
Work Experience
- Software Developer – Paragon Recruiting / DENSO
-
- Grand Rapids, MI
- Fall 2020 – Present
-
- Created firmware for proof-of-concept UWB phone-as-a-key automotive systems
- Mentored junior developers, refactored existing software, and architected new features
- Utilized both hardware and software debugging skills to diagnose and fix complex system bugs
- Senior – Ernst and Young
-
- Grand Rapids, MI
- Spring 2019 – Fall 2020
-
- Tested connected products for security flaws
- Crafted proof-of-concept exploits to demonstrate system vulnerabilities to clients
- Reverse engineered hardware and software systems for purposes of vulnerability research
- Security Researcher – GRIMM
-
- Grand Rapids, MI
- Fall 2016 – Spring 2019
-
- Assessed automotive and general embedded systems for security issues
- Created tools to disassemble and analyze software targeted to uncommon processor architectures
- Designed open-source tools to replace expensive proprietary diagnostic products
- Senior Developer – Modustri
-
- Grand Rapids, MI
- Fall 2015 – Fall 2016
-
- Lead development of an Ember.js and Ruby on Rails webapp used to inspect heavy machinery
- Worked with product teams to help shape new features and improve quality
- Developer & Maker – Atomic Object, LLC
-
- Grand Rapids, MI
- Spring 2012 – Fall 2015
-
- Worked directly with clients in multidisciplinary teams on a wide variety of projects
- Created an embedded Linux platform and control applications for industrial laundry equipment
- Wrote embedded control software and user-facing Windows GUI for a pipeline inspection tool
- Software Developer – Lasalle Technology Group, LTD
-
- Hancock, MI
- Summer 2009 – Spring 2012
-
- Wrote software to manage FIX dictionaries and monitor financial trading communications
- Created desktop Eclipse applications as well as network inspection applications in C
- Responsible for ports including Solaris and Linux
Education & Honors
- Michigan Technological University
-
- Houghton, MI
-
- B.S. Computer Science, Computer Engineering
- Cum Laude
- Member Upsilon Pi Epsilon Honor Society
- Blue Marble Security, Michigan Tech Enterprise Program
-
- Teams: Decepticam, Motor Controller, Autobot
-
- Worked in a variety of small interdisciplinary groups
- Responsible for low-level software drivers and software of Autobot, a robot for the AUVSI Intelligent Ground Vehicle Competition
- Designed hardware and software for a brushed DC motor controller
Personal Projects
- Fast Ethernet to 100-BaseT1/BroadR-Reach media converter
- LPC5514-based USB-HS CAN-FD adapter
- Binary Ninja architecture plugins for Renesas V850 and PowerPC VLE support
- Binary Ninja plugin to add memory mapped peripheral annotations based on ARM CMSIS-SVD files
- Rust+STM32-based SNES to CD-i controller adapter
Skills
- Outstanding troubleshooting and diagnostic skills
- Competency with C, Python, Ruby, JavaScript, HTML/CSS, C#, .NET, Java, and other languages
- Skilled in the use of disassemblers such as Binary Ninja and objdump
- Literate in various assembly languages, including ARM, PowerPC VLE, Xtensa, and V850
- Familiarity with FreeRTOS and embedded systems
- Experience building custom Linux board support packages with Yocto
- Design, drafting, layout, and assembly of moderately complex electronics
- Using lab equipment such as soldering irons, hot-air rework stations, oscilloscopes, and logic analyzers


Event Location:
Microsoft Campus - Las Colinas
7000 State Hwy 161
Irving, Texas
Abstract:
Microsoft SharePoint Server is a fantastic option to surface SQL Server Business Intelligence tools to end users (SSRS, PowerVIew and PowerPivot, SQL Tabular, SQL BISM). Yet, this tends to be a little tricky because the SQL Server Professionals do not understand all SharePoint aspects and vise versa. To make matters worse, SharePoint architecture underwent a huge change from kerberos to claims and this meant a lot of pervious concepts don't appy and lot of new tools are not claims aware. The objective of this session is to clarify 1. Clarify how to configure SQL BI in a Claims based SharePoint 2013 environment. 2. What works and what does not work with claims. 3. All necessary terms and concepts provided to SQL Professionals who will them be able to work with the SharePoint teams fearlessly. 4. Advanced consultants, will be able to configure the integration between SharePoint and SQL BI completely.
Speaker(s): Abhishek Srivastava,
Abstract:
The way companies are thinking about data and business intelligence is changing fast. Traditional models for building and delivering BI are under siege from new technologies and new methodologies. As we work through the hype cycles of end-user BI and big data approaches, we’ll discuss how these are affecting enterprise BI, as practiced both inside IT and outside of IT. We’ll discuss how new trends and tools conflict and coexist with traditional IT BI practice. And we’ll discuss what the future of Enterprise BI might actually look like when the dust settles. What role will IT play in Business intelligence? What role with the data warehouse play? Are they going away, or just changing? And what skills might be most important for the next 10 years?
Speaker(s): David Browne,
Abstract:
The traditional data warehouse has served us well for many years, but new trends are causing it to break in four different ways: data growth, fast query expectations from users, non-relational/unstructured data, and cloud-born data. How can you prevent this from happening? Enter the modern data warehouse, which is able to handle and excel with these new trends. It handles all types of data (Hadoop), provides a way to easily interface with all these types of data (PolyBase), and can handle big data and provide fast queries. Is there one appliance that can support this modern data warehouse? Yes! It is the Parallel Data Warehouse (PDW). In this session I will dig into the details of the modern data warehouse and PDW. I will give an overview of the PDW hardware and software architecture, identify what makes PDW different, and demonstrate the increased performance.
Speaker(s): James Serra,
Abstract:
Cube functions have existed since Excel 2007, but they’re not as well known nor as well publicized as other methods to obtain data from Analysis Services/PowerPivot sources. Business Analysts may feel confined to tabular (symmetrical) reports with pivot tables. BI Developers may avoid Excel because they want the ability to write advanced calculations in MDX and the extensive formatting capabilities of Reporting Services. And Power View limits you to the sets, calculations, and captions available in the data source and doesn’t provide drillthrough detail. We’ll start with the basics of how to write and use cube functions, then employ them to build a nicely formatted, asymmetrical, parameter-driven report that overcomes the previously noted limitations.
Speaker(s): Meagan Longoria,
Abstract:
You have geospatial data and you know that plotting it on a map will deliver insights. Or maybe you keep hearing “geospatial” as a current BI buzzword and you want to be informed about your options when you get to it. The Microsoft BI stack provides several options for visualizing location data. But how do you know which tool will best serve your purpose, or what factors are important in making this decision? We’ll identify factors to consider when choosing a tool to visualize your data in maps such as system requirements, availability and type of location data, required level of technical understanding, and more. You’ll leave the session confident in your ability to choose the best tool within Excel and SQL Server.
Speaker(s): Meagan Longoria,
Abstract:
Before SQL Server 2012, it was easy to develop several SSIS packages in a project and deploy each package as you complete it. However SQL Server 2012 introduces the project deployment model. With its awesome features comes the limitation that you can no longer deploy a single package. You must deploy the whole project every time! How do you deploy a project that contains a mix of deployed packages, ready to deploy packages and packages in development? In this session I demonstrate common problems that arise in the package development lifecycle that affect project deployment. I will then demonstrate how to use Team Foundation Server to address these problems. I will develop the story for handling packages at various stages of development using TFS.
Speaker(s): Russel Loski,
Abstract:
This session is going to help create a dimensional Data Mart from the AdventureWorks database that includes dimension tables and 2 example fact tables. The Kimball spreadsheet for documenting a Data Mart will be used to reenforce the need for Requirements and Functional specifications. A brief review of ETL for Slowly Changing Dimension and population of the Fact will be deomstrated as well as a simple cube for reporting.
Speaker(s): Thomas LeBlanc,
Abstract:
This talk will cover the basics of Apache Pig and how it relates to the Hadoop ecosystem. Wes will start with the basics of the Pig scripting language and move towards how it can be used to power your traditional ETL tasks in a Hadoop cluster. The agenda includes: • History and overview of Pig scripting language • Examples of how to use Pig • Demo of how to use Pig to complement your existing ETL jobs
Speaker(s): Wesley Floyd,
Abstract:
Storytelling seems to be a lost art form; in this fast-paced world people are more interested in getting as many bits of information as they can. But without a story, something to pull all the data together, the target audience will probably gloss over your message. Throwing a few numbers and charts at the reader has become pretty acceptable nowadays. But to make something truly memorable, and hopefully shared with someone else, you need some kind of story. You need something to tie it all together, to give it some meaning. That’s where Microsoft steps in with its latest addition to the Business Intelligence Analytics space with an add-in to Excel called PowerMap.
Speaker(s): marek koenig,
Abstract:
Natural language query (NLQ) allows users to quickly answer questions using simple English-language questions. In this session, we will learn how to enable NLQ in your data models and explore the mechanisms behind this functionality.
Speaker(s): Bryan Smith,
Abstract:
This session will demonstrate how to incorporate advanced Time Intelligence into your Power Pivot model. We’ll utilize Data Analysis eXpressions language (DAX) to build calculations such as Month to Date, Year to Date, Year over Year, etc. We’ll also be covering reporting best practices for trending and comparative data. You’ll soon be ready to quickly and accurately report up current and past performance metrics to help the decisions makers make more informed and up-to-date decisions.
Speaker(s): Josh George,
Abstract:
What is Hadoop you ask? Hadoop is an open-source software framework for storage and large-scale processing of data sets on clusters of commodity hardware. In this session, Eric will walk you through Apache Hadoop, what it is and what it isn’t, deployment options, how to use it, and finish with some interesting use cases.
Speaker(s): Eric Mizell,
Abstract:
In this session, we will continue your Power BI journey and discuss the compelling visualization capabilities of Excel Power View. You will learn just how easy it is to create presentation-ready visualizations and tell an interactive story with your data. If you are intrigued by what capabilities you can unlock with Power BI, then come learn how you can leverage Power View to enhance your analytics experience and maximize value for your organization.
Speaker(s): Jeff Johnston,
Abstract:
This session will cover building models in PowerPivot, the semantic layer of Power BI. It will include examples from both dimensional and non-dimensional models, along with limitations, workarounds and best practices. You will also learn how to incorporate images and other types of content. The session will include a basic introduction of the Data Analysis Expressions Language (DAX) and cover some of the most common expressions that are used in data models.
Speaker(s): Brian Gogle,
Abstract:
The hardest part of the analyst's job is finding data to support his or her work. And once that data is found, it is often in less than ideal shape for our needs. With Excel Power Query, the analyst now has capabilities to find and cleanse data, resulting in huge time savings. In this session, you will learn the basics of working with Power Query.
Speaker(s): Bryan Smith,
Abstract:
In this session you will learn how to provide valuable data insights through data discovery and visualisation with Microsoft’s Power BI capabilities. You'll learn how to connect and discover the world's data to enhance data discovery over your own and externally available datasets and how to combine multiple datasets together. You'll also learn how to use existing and new data visualisation capabilities together using Power View and Power Map in Excel 2013, and get a deep drilldown into the Power BI capabilities.
Speaker(s): Derek Dai,
Abstract:
Building off the earlier session, "Finding Cleansing Data with Excel Power Query", we will explore more advanced techniques for cleansing data using Excel Power Query including the use of Power Query expressions. Armed with these techniques, analysts should feel confident tackling some of the gnarliest data cleansing challenges.
Speaker(s): Bryan Smith,
Abstract:
This session will focus on the Microsoft technologies surrounding HDInsight, Microsoft's cloud-based Hadoop solution. We will cover HDFS integration through Power Query, Hive integration through Power Pivot, and HDInsight data integration through the SSIS Connector. In addition, we will also look at joining structured Big Data with semi-structured Hadoop data using Parallel Data Warehouse and the Polybase query technology.
Speaker(s): Blake Price,
Abstract:
85% of the world’s data is unstructured and over 20 billion terabytes of data is fast coming to organizations. And business wants more data. Welcome to the world of Hadoop. Hadoop allows organizations to store massive amount of data in one single place regardless of structure and format and provides a way to interact with the data using SQL via Hive. Hive is the SQL de facto standard for querying Hadoop data. It is rich with SQL semantics and utilizes YARN Tez frameworks that powers interactive query for Hive.
Speaker(s): Rommel Garcia,
Abstract:
The session will take a common Business customer loyalty program problem from beginning to end results. We will cover a framework of analyzing the business problem identifying additional sources of data or business considerations. Then applying techniques to identify the potential customers and placing the business problem into an opportunity, which not only helps the customer but also benefits the company. The results of these efforts I was able to generate 40.1 million dollars of additional sales revenue, which translated into 18 million of Earnings before interest and taxes.
Speaker(s): Andy Eggers,
Abstract:
In this session, I'll walk you through strategies tactics that you could use to empower your business users to create their own BI reports.
Speaker(s): Paras Doshi,
Abstract:
Regardless of what business we are in, we are generating large volumes of data. Most of this data is unstructured. Valuable information exists in unstructured data. The challenge is how do we find this information, and perhaps even more importantly; draw meaningful correlations with structured data. Mahout and R allow us to find patterns in unstructured data and correlate text and numbers.
Speaker(s): Don Hilborn,
Abstract:
In this session, we will travel the course of how some organizations are embracing the concept of a Modern Data Warehouse by unifying different technologies for handling large volumes of data. Parallel Data Warehouse, or PDW, is a solution that offers high performance data warehousing using the MPP architecture and ability to reach over and combine data from the hadoop platform. We will learn how this technology works and offers extreme performance and yet a very easy platform to manage for the DBA, Infrastructure, and Developers alike.
Speaker(s): Sanjay Kaul,
Abstract:
It's not too hard to build a data flow in SSIS quickly. Building a FAST data flow can be a little tricky. In this session I'll show you the things you should be thinking about when designing your data flow and some tricks that can help you move your data faster. In this demo heavy session we will work through examples of slow data flow scenarios and fix them with simple techniques you can put to work Monday morning!
Speaker(s): Tim Costello,
This is a list of speakers from the XML Guidebook records. The details and URLs were valid at the time of the event.
Contact: http://www.parasdoshi.com
Paras works on Business Intelligence Projects at SolidQ USA. He is Microsoft community contributor award recipient (2011) and a blogger.
Contact: http://derekdb.wordpress.com/
Over 10 years’ experience in database design, development, and administration using a wide variety of tools and technologies. Having focused on Business Intelligence using the SQL Server BI stack (SSAS, SSRS, SSIS, Power-pivot, Semantic Model and Data Mining) with solid knowledge on SQL Server DB Core engine. And extensive experience with Microsoft development tools. PASS VC Leader; MCT; MSCE BI and Data Platform
Sanjay is a Technology Specialist at Microsoft who specializes in helping customers envision, design, and deploy data life cycle, data warehouse, and business intelligence focused solutions using the Microsoft platform. In his 12th year at Microsoft, Sanjay has spent time in Microsoft’s consulting group, enterprise SQL Server sales, SQL Server BI Architect at the Microsoft Technology Center in Minneapolis, before moving to his current role of Data Warehouse Technology Specialist.
Eric is the Director of Solution Engineering at Hortonworks working in the field to integrate Hadoop into existing architectures. He has been in the Big Data space for 4+ years and has help hundreds of companies solve their data problems. Prior to Hortonworks, Eric was the Director of Field Engineering for Terracotta. He has over 20 years of experience in IT which includes Network Engineering, Software Engineering and Solution Engineering. Eric has presented at NFJS, DevNexus, AJUG, and SUG.
I have a total of 16 years of experience in IT. I work as a SharePoint architect Goldman Sachs. As a sharepoint architect, I has configured PowerPivot, PowerView and SSRS on SharePoint 2013. I also own the SQL Server infrastrcture for our multi-TB SharePoint farm. I engineered the resiliency, DR, Disk and Backup infrastructure for our SharePoint farm. I have extensive experience in SSAS, SSRS, SSIS, and Data Warehousing on SQL Server
LinkedIn: http://www.linkedin.com/in/meaganlongoria/
Contact: http://datasavvy.me
Meagan Longoria is a business intelligence consultant with Denny Cherry Associates, and lives in Denver, Colorado. She is a Microsoft Data Platform MVP. Meagan spends a lot of time thinking about how to use data integration, DAX, and data visualization techniques to make data useful for people. She enjoys sharing her knowledge and experiences at conferences and user group meetings, as well as through her blog (DataSavvy.me).
LinkedIn: http://www.linkedin.com/in/bgogle
Contact: http://briangogle.com
I have had a very diverse career that has always been very focused on insights and how they improve performance. I am currently the Data and Analytics Lead for the Central Region for Neudesic. Prior to consulting I was Vice President of Information Services with Mosaic, a retail services company. leading a forty person team in the U.S. and Canada and architecting a Microsoft BI solution that was accessed by over 1,000 clients from over 140 retailers and retail manufacturers. Before joining Neudesic I served as the Data Management Practice Area Lead for Slalom Consulting in Dallas.
Just Andy
LinkedIn: https://www.linkedin.com/pub/bryan-smith/17/98b/161
Bryan is a Data Solution Specialist with Microsoft Las Colinas, focused on data-driven solutions in the Azure cloud. He also teaches analytics technologies within the MBA amp; MSBA programs at SMU Cox School of Business.
I’m a Technology Architect at the Microsoft Technology Center in Dallas. And my job is to help customers design and implement SQL Server solutions. As part of my job I get to talk to a lot of BI shops about what they’re doing, how they perceive the their role in Enterprise Business Intelligence, what they are being asked by their businesses, and how they are responding to new challenges.
Don has over two decades of experience implementing data driven analytic solutions that facilitate evidence-based decisions and influence strategic direction. Don has held lead Data Architect roles for Anadarko, Invesco, Boeing, Arthur Andersen and Compaq where he architected and implemented terabyte and petabyte data systems.
Rommel Garcia has developed distributed systems for the past 10 years and extensively used SQL semantics for processing and querying data. He led Enterprise Architecture at various Fortune 500 companies. Rommel also provided leadership and execution of Data Architecture services across different verticals like Energy/Power, Retail, Manufacturing, Logistics, and Finance.
LinkedIn: http://www.linkedin.com/profile/view?id=29648544amp;trk=hb_tab_pro_top
Contact: http://Thomas-LeBlanc.com
Thomas LeBlanc (Microsoft Data Platform MVP) is a Data Warehouse Architect in Baton Rouge, and uses his 30+ years in IT to develop OLTP systems with normalized databases for high-performing T-SQL and dimensional data marts. Development is done in SSIS, SSAS, SSRS, Power BI, and Excel. As a PASS volunteer, he is past chair of Excel BI and Data Arch VCs and is active in the Baton Rouge Analytics and SQL Server User groups, as well as SQLSaturday in Baton Rouge. You can find his blog at TheSmilingDBA.BlogSpot.com and website at Thomas-LeBlanc.com
LinkedIn: https://www.linkedin.com/pub/bryan-smith/17/98b/161
Bryan is a Data Solution Specialist with Microsoft Las Colinas, focused on data-driven solutions in the Azure cloud. He also teaches analytics technologies within the MBA amp; MSBA programs at SMU Cox School of Business.
LinkedIn: http://www.linkedin.com/in/marekkoenig/
Contact: http://blog.slalom.com/author/marekkoenig/
Marek Koenig is a BI consultant with Slalom Consulting. He specializes in geospatial visualization. In his free time he enjoys cycling, tennis, or anything else outdoors.
LinkedIn: http://www.linkedin.com/in/russloski
Contact: http://www.sqlmovers.com
Russ Loski is a SQL Server BI Developer based in Dallas-Fort Worth. He current works as a Data Analytics Engineer for Navisite, a remote managed IT services company. Twenty years ago, he began working with SQL Server 6.5. He has since continued to develop applications connected to all of the versions of SQL Server. He has worked with clients in industries from insurance to healthcare, from movie theaters to American football. Russ is a regular speaker at SQLSaturday events, as well as the SQL Server Users Groups in the North Texas region. Russ likes working with data in various shapes.
LinkedIn: http://www.linkedin.com/pub/tim-costello/8/b38/a02/
Contact: http://www.timcost.com
Tim Costello is an MCITP, MCTS specializing in etl and data analytics for Interworks Inc. Tim is an international speaker that is always looking for opportunities to share his passion for SQL Server, Tableau and data visualization. Tim is active in the SQL community and leads a data visualization focused user group in the Dallas area.
LinkedIn: http://www.linkedin.com/in/JamesSerra
Contact: http://www.JamesSerra.com
James Serra is a big data and data warehousing solution architect at Microsoft. He is a thought leader in the use and application of Big Data and advanced analytics. Previously, James was an independent consultant working as a Data Warehouse/Business Intelligence architect and developer. He is a prior SQL Server MVP with over 35 years of IT experience. James is a popular blogger (JamesSerra.com) and speaker. He is the author of the book “Reporting with Microsoft SQL Server 2012”.
LinkedIn: https://www.linkedin.com/pub/bryan-smith/17/98b/161
Bryan is a Data Solution Specialist with Microsoft Las Colinas, focused on data-driven solutions in the Azure cloud. He also teaches analytics technologies within the MBA amp; MSBA programs at SMU Cox School of Business.
Contact: http://www.slalom.com
Josh George is a Business Intelligence Solution Architect with over 10 years’ experience designing, building and managing enterprise-class custom technology solutions for small, medium and large organizations. He specializes in Business Intelligence and Enterprise Data Architecture solution development, Project and Team Management, Data Warehousing and Data Modeling, ETL, OLAP, Dashboards, and Business Analysis, and is part of Slalom’s Technology Solutions group.
Jeff Johnston is the Business Intelligence Practice Leader for Artis Consulting. Based in Dallas, TX, Jeff provides guidance for client engagements, solution strategy, Microsoft partnership and sales execution. Jeff has spoken at various Microsoft events including MSBIC and SharePoint Techfest. Jeff holds an MBA in Strategy Entrepreneurship and has several Microsoft certifications including MCITP-BI, MCDBA, and MCSD.
Wes Floyd is a Solution Engineer at Hortonworks based in Atlanta, GA. He works with customers in the Southeast to complement their EDW SQL based projects with Hadoop as a data lake addition to their architecture. Wes's background is in Java development and SQL design across a variety of platforms.
LinkedIn: http://www.linkedin.com/in/meaganlongoria/
Contact: http://datasavvy.me
Meagan Longoria is a business intelligence consultant with Denny Cherry Associates, and lives in Denver, Colorado. She is a Microsoft Data Platform MVP. Meagan spends a lot of time thinking about how to use data integration, DAX, and data visualization techniques to make data useful for people. She enjoys sharing her knowledge and experiences at conferences and user group meetings, as well as through her blog (DataSavvy.me).
Contact: http://www.artisconsulting.com
Blake has been a consultant in the Microsoft Business Intelligence space for 15 years and is one of the founders of Artis Consulting. He has deep experience with large-scale Data Warehousing solutions and has participated in the Microsoft Big Data Incubation program.
The following is a list of sponsors that helped fund the event.